Namespaces
Variants

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

From cppreference.net

C++
Containers library
std::set
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 bleibt unverändert, wie angefordert.)
Definiert im Header <set>
template < class Key, class Compare, class Alloc >

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Vergleicht die Inhalte von zwei set s.

Sei value_type der Werttyp von set (d.h., typename set :: 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 das Konzept 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 - set 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 set .
3-7) Linear in der Größe des set .

Hinweise

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

(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 <set>
int main()
{
    const std::set
        a{1, 2, 3},
        b{1, 2, 3},
        c{7, 8, 9, 10};
    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