Namespaces
Variants

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

From cppreference.net

C++
Containers library
std::map
Member functions
Non-member functions
operator== operator<=>
(C++20)
(C++20)

operator!= operator< operator> operator<= operator>=
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20)
Deduction guides (C++17)
(Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags und Attribute gemäß den Anweisungen unverändert bleiben sollen und die Tabellenzellen leer sind.)
Definiert im 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) (constexpr seit C++26)
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 >

/* siehe unten */
operator <=> ( const std:: map < Key, T, Compare, Alloc > & lhs,

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

Vergleicht die Inhalte zweier map s.

Sei value_type der Werttyp von map (d.h., typename map :: value_type ):

1,2) Prüft, ob die Inhalte von lhs und rhs gleich sind, das heißt, ob sie die gleiche Anzahl an Elementen haben und jedes Element in lhs mit dem Element in rhs an derselben Position übereinstimmt.
Entspricht:

return std:: distance ( lhs. begin ( ) , lhs. end ( ) )
== std:: distance ( rhs. begin ( ) , rhs. end ( ) )
&& std:: equal ( lhs. begin ( ) , lhs. end ( ) , rhs. begin ( ) ) ;

(bis C++14)

return std:: equal ( lhs. begin ( ) , lhs. end ( ) , rhs. begin ( ) , rhs. end ( ) ) ;

(seit C++14)
Wenn value_type nicht EqualityComparable ist, ist das Verhalten undefiniert.
3-7) Vergleicht die Inhalte von lhs und rhs lexikographisch.
3-6) Entspricht return std:: lexicographical_compare ( lhs. begin ( ) , lhs. end ( ) ,
rhs. begin ( ) , rhs. end ( ) ) ; .
Wenn eine der folgenden Bedingungen erfüllt ist, ist das Verhalten undefiniert:
7) Entspricht return std:: lexicographical_compare_three_way ( lhs. begin ( ) , lhs. end ( ) ,
rhs. begin ( ) , rhs. end ( ) ,
synth-three-way ) .
Der Rückgabetyp ist der Rückgabetyp von synth-three-way (d.h., synth-three-way-result  < value_type > ).
Wenn eine der folgenden Bedingungen erfüllt ist, ist das Verhalten undefiniert:
  • T erfüllt nicht die Anforderungen von three_way_comparable .
  • operator < ist nicht für Werte des Typs (möglicherweise const-qualifiziert) value_type definiert.
  • operator < stellt keine Totalordnung her.

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

(seit C++20)

Inhaltsverzeichnis

Parameter

lhs, rhs - map s, deren Inhalte verglichen werden sollen

Rückgabewert

Operator lhs und rhs
sind gleich 		lhs ist
lexikografisch größer 		rhs ist
lexikografisch größer
operator == true false
operator ! = false true
operator < false false true
operator <= true
operator > false true false
operator >= true
operator <=> ein Wert gleich ​ 0 ​ ein Wert größer als ​ 0 ​ ein Wert kleiner als ​ 0 ​

Komplexität

1,2) Konstant, falls lhs und rhs unterschiedliche Größe haben, andernfalls linear in der Größe der map .
3-7) Linear in der Größe der map .

Hinweise

Die relationalen Operatoren sind definiert in Bezug auf value_type 's operator < .

(bis C++20)

Die relationalen Operatoren sind nicht definiert. Der umgeschriebene Kandidat operator <=> wird durch Überladungsauflösung ausgewählt.

operator <=> verwendet value_type 's operator <=> falls möglich, andernfalls value_type 's operator < . Insbesondere, wenn der value_type selbst keinen operator <=> bereitstellt, aber implizit in einen dreiseitig vergleichbaren Typ konvertierbar ist, wird diese Konvertierung anstelle von operator < verwendet.

(seit C++20)

Diese nicht-Member-Vergleichsoperatoren verwenden nicht Compare , um Elemente zu vergleichen.

Beispiel

Diesen Code ausführen 
#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
    (""
        "Vergleiche gleiche Container:" &&
        (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 &&
        "Vergleiche ungleiche Container:" &&
        (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 &&
    "");
}

Fehlerberichte

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

DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
LWG 3431 C++20 operator <=> erforderte nicht, dass T
das Konzept three_way_comparable modelliert 		erfordert