Namespaces
Variants

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

From cppreference.net

C++
Containers library
std::multimap
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 leer sind. Die Struktur und Formatierung bleiben unverändert.)
Definiert im Header <map>
template < class Key, class T, class Compare, class Alloc >

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

const std:: multimap < Key, T, Compare, Alloc > & rhs ) ;
(1) (constexpr seit C++26)
template < class Key, class T, class Compare, class Alloc >

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

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

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

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

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

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

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

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

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

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

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

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

Vergleicht die Inhalte von zwei multimap s.

Sei value_type der Werttyp von multimap (d.h., typename multimap :: 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 < etabliert keine Totalordnung .

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

(seit C++20)

Inhaltsverzeichnis

Parameter

lhs, rhs - multimap 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 des multimap .
3-7) Linear in der Größe des multimap .

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::multimap<int, char> a{{1, 'a'}, {2, 'b'}, {3, 'c'}};
    std::multimap<int, char> b{{1, 'a'}, {2, 'b'}, {3, 'c'}};
    std::multimap<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 Korrigiertes Verhalten
LWG 3431 C++20 operator <=> erforderte nicht, dass T
das Konzept three_way_comparable modelliert 		erfordert