Namensräume
Varianten
Aktionen

operator==,!=,<,<=,>,>=<=>(std::map)

Von cppreference.com
< cpp‎ | container‎ | map

[Bearbeiten-Vorlage]
 
C++
 
Container-Bibliothek
 
std::map
Memberfunktionen
Nicht-Member-Funktionen
operator==operator<=>
(C++20)
(C++20)  

operator!=operator<operator>operator<=operator>=
(bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)
Leitfaden zur Ableitung (C++17)
 
Definiert in Header <map>
template< class Key, class T, class Compare, class Alloc >

bool operator==( const std::map<Key, T, Compare, Alloc>& lhs,

                 const std::map<Key, T, Compare, Alloc>& rhs );
 (1)
template< class Key, class T, class Compare, class Alloc >

bool operator!=( const std::map<Key, T, Compare, Alloc>& lhs,

                 const std::map<Key, T, Compare, Alloc>& rhs );
 (2) (bis C++20)
template< class Key, class T, class Compare, class Alloc >

bool operator<( const std::map<Key, T, Compare, Alloc>& lhs,

                const std::map<Key, T, Compare, Alloc>& rhs );
 (3) (bis C++20)
template< class Key, class T, class Compare, class Alloc >

bool operator<=( const std::map<Key, T, Compare, Alloc>& lhs,

                 const std::map<Key, T, Compare, Alloc>& rhs );
 (4) (bis C++20)
template< class Key, class T, class Compare, class Alloc >

bool operator>( const std::map<Key, T, Compare, Alloc>& lhs,

                const std::map<Key, T, Compare, Alloc>& rhs );
 (5) (bis C++20)
template< class Key, class T, class Compare, class Alloc >

bool operator>=( const std::map<Key, T, Compare, Alloc>& lhs,

                 const std::map<Key, T, Compare, Alloc>& rhs );
 (6) (bis C++20)
template< class Key, class T, class Compare, class Alloc >

synth-three-way-result<T>
    operator<=>( const std::map<Key, T, Compare, Alloc>& lhs,

                 const std::map<Key, T, Compare, Alloc>& rhs );
 (7) (seit C++20)

Vergleicht den Inhalt von zwei maps.

1,2) Prüft, ob der Inhalt von lhs und rhs gleich ist, d. h. sie haben die gleiche Anzahl von Elementen und jedes Element in lhs ist mit dem Element in rhs an der gleichen Position gleich.
3-6) Vergleicht den Inhalt von lhs und rhs lexikographisch. Der Vergleich wird durch eine Funktion durchgeführt, die äquivalent zu std::lexicographical_compare ist. Dieser Vergleich ignoriert die Ordnung von Compare des map.
7) Vergleicht den Inhalt von lhs und rhs lexikographisch. Der Vergleich wird so durchgeführt, als ob std::lexicographical_compare_three_way(lhs.begin(), lhs.end(),
                                       rhs.begin(), rhs.end(), synth-three-way) aufgerufen würde. Dieser Vergleich ignoriert die Ordnung von Compare des map.
Der Rückgabetyp ist der Rückgabetyp von synth-three-way (d. h. synth-three-way-result <T>).
Wenn keine der folgenden Bedingungen erfüllt ist, ist das Verhalten undefiniert
  • T modelliert three_way_comparable.
  • < ist für Werte des Typs (möglicherweise const-qualifiziert) T definiert, und < ist eine totale Ordnungsrelation.

Die Operatoren <, <=, >, >= und != sind synthetisiert aus operator<=> und operator== beziehungsweise.

 (seit C++20)

Inhalt

[bearbeiten] Parameter

lhs, rhs - maps, deren Inhalte verglichen werden sollen
-
T, Key müssen die Anforderungen an EqualityComparable erfüllen, um die Überladungen (1,2) verwenden zu können.
-
Key muss die Anforderungen an LessThanComparable erfüllen, um die Überladungen (3-6) verwenden zu können. Die Ordnungsrelation muss eine totale Ordnung herstellen.

[bearbeiten] Rückgabewert

1) true, wenn die Inhalte der maps gleich sind, false sonst.
2) true, wenn die Inhalte der maps nicht gleich sind, false sonst.
3) true, wenn der Inhalt von lhs lexikographisch kleiner als der Inhalt von rhs ist, false andernfalls.
4) true, wenn der Inhalt von lhs lexikographisch kleiner oder gleich dem Inhalt von rhs ist, false andernfalls.
5) true, wenn der Inhalt von lhs lexikographisch größer als der Inhalt von rhs ist, false andernfalls.
6) true, wenn der Inhalt von lhs lexikographisch größer oder gleich dem Inhalt von rhs ist, false andernfalls.
7) Die relative Ordnung des ersten Paares nicht-gleicher Elemente in lhs und rhs, wenn solche Elemente vorhanden sind, andernfalls lhs.size() <=> rhs.size().

[bearbeiten] Komplexität

1,2) Konstant, wenn lhs und rhs eine unterschiedliche Größe haben, sonst linear zur Größe des map.
3-7) Linear zur Größe des map.

[bearbeiten] Hinweise

Die relationalen Operatoren sind in Bezug auf den `operator<` des Elementtyps definiert.

 (bis C++20)

Die relationalen Operatoren sind in Bezug auf synth-three-way definiert, der, wenn möglich, `operator<=>` und andernfalls `operator<` verwendet.

Insbesondere, wenn das Element selbst keinen `operator<=>` bereitstellt, aber implizit in einen dreiwertig vergleichbaren Typ konvertiert werden kann, wird diese Konvertierung anstelle von `operator<` verwendet.

 (seit C++20)

[bearbeiten] Beispiel

Führen Sie diesen Code aus
#include <cassert>
#include <compare>
#include <map>
 
int main()
{
    std::map<int, char> a{{1, 'a'}, {2, 'b'}, {3, 'c'}};
    std::map<int, char> b{{1, 'a'}, {2, 'b'}, {3, 'c'}};
    std::map<int, char> c{{7, 'Z'}, {8, 'Y'}, {9, 'X'}, {10, 'W'}};
 
    assert
    (""
        "Compare equal containers:" &&
        (a != b) == false &&
        (a == b) == true &&
        (a < b) == false &&
        (a <= b) == true &&
        (a > b) == false &&
        (a >= b) == true &&
        (a <=> b) != std::weak_ordering::less &&
        (a <=> b) != std::weak_ordering::greater &&
        (a <=> b) == std::weak_ordering::equivalent &&
        (a <=> b) >= 0 &&
        (a <=> b) <= 0 &&
        (a <=> b) == 0 &&
 
        "Compare non equal containers:" &&
        (a != c) == true &&
        (a == c) == false &&
        (a < c) == true &&
        (a <= c) == true &&
        (a > c) == false &&
        (a >= c) == false &&
        (a <=> c) == std::weak_ordering::less &&
        (a <=> c) != std::weak_ordering::equivalent &&
        (a <=> c) != std::weak_ordering::greater &&
        (a <=> c) < 0 &&
        (a <=> c) != 0 &&
        (a <=> c) <= 0 &&
    "");
}

[bearbeiten] Defect reports

Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
LWG 3431 C++20 operator<=> erforderte nicht, dass T
three_way_comparable modelliert.		 requires
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/container/map/operator_cmp&oldid=135940"