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

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Dienstprogramm-Bibliotheken

Sprachunterstützung Typunterstützung (Basistypen, RTTI) Bibliotheks-Feature-Test-Makros (C++20) Programm-Dienstprogramme Variadische Funktionen initializer_list (C++11) is_constant_evaluated (C++20) is_within_lifetime (C++26) source_location (C++20) Coroutine-Unterstützung (C++20) Vertragsunterstützung (C++26) Drei-Wege-Vergleich three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Allgemeine Hilfsmittel Funktionsobjekte Bit-Manipulation (C++20) bitset hash (C++11) Relationale Operatoren (in C++20 veraltet) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Ganzzahl-Vergleichsfunktionen cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Swap und Typ-Operationen swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Gemeinsame Vokabulartypen pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

std::pair

Memberfunktionen

pair::pair

pair::operator=

pair::swap (C++11)

Nicht-Member-Funktionen

make_pair

operator==operator!=operator<operator<=operator>operator>=operator<=> (bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)(C++20)

swap(std::pair) (C++11)

get(std::pair) (C++11)

Hilfsklassen

tuple_size<std::pair> (C++11)

tuple_element<std::pair> (C++11)

basic_common_reference<std::pair> (C++23)

common_type<std::pair> (C++23)

formatter<std::pair> (C++23)

piecewise_construct_t (C++11)

Deduktionshilfen(C++17)

 

Definiert in der Header-Datei <utility>
	(1)
template< class T1, class T2, class U1, class U2 > bool operator==( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );			(bis C++14)
template< class T1, class T2, class U1, class U2 > constexpr bool operator==( const std::pair<T1, T2>& lhs,                            const std::pair<U1, U2>& rhs );			(seit C++14)
		(2)
template< class T1, class T2, class U1, class U2 > bool operator!=( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );				(bis C++14)
template< class T1, class T2, class U1, class U2 > constexpr bool operator!=( const std::pair<T1, T2>& lhs,                            const std::pair<U1, U2>& rhs );				(seit C++14) (bis C++20)
			(3)
template< class T1, class T2, class U1, class U2 > bool operator<( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );					(bis C++14)
template< class T1, class T2, class U1, class U2 > constexpr bool operator<( const std::pair<T1, T2>& lhs,                           const std::pair<U1, U2>& rhs );					(seit C++14) (bis C++20)
				(4)
template< class T1, class T2, class U1, class U2 > bool operator<=( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );						(bis C++14)
template< class T1, class T2, class U1, class U2 > constexpr bool operator<=( const std::pair<T1, T2>& lhs,                            const std::pair<U1, U2>& rhs );						(seit C++14) (bis C++20)
					(5)
template< class T1, class T2, class U1, class U2 > bool operator>( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );							(bis C++14)
template< class T1, class T2, class U1, class U2 > constexpr bool operator>( const std::pair<T1, T2>& lhs,                           const std::pair<U1, U2>& rhs );							(seit C++14) (bis C++20)
						(6)
template< class T1, class T2, class U1, class U2 > bool operator>=( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );								(bis C++14)
template< class T1, class T2, class U1, class U2 > constexpr bool operator>=( const std::pair<T1, T2>& lhs,                            const std::pair<U1, U2>& rhs );								(seit C++14) (bis C++20)
template< class T1, class T2, class U1, class U2 > constexpr std::common_comparison_category_t<synth-three-way-result<T1, U1>,                                             synth-three-way-result<T2, U2>>     operator<=>( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );							(7)	(seit C++20)

1,2) Prüft, ob beide Elemente von lhs und rhs gleich sind, d.h. vergleicht lhs.first mit rhs.first und lhs.second mit rhs.second.

Das Verhalten ist undefiniert, wenn Typ und Wertkategorie von entweder lhs.first == rhs.first oder lhs.second == rhs.second nicht die BooleanTestable-Anforderungen erfüllen.	(bis C++26)
Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn sowohl decltype(lhs.first == rhs.first) als auch decltype(lhs.second == rhs.second) boolean-testable modellieren.	(seit C++26)

3-6) Vergleicht lhs und rhs lexikographisch mittels operator<, d.h. vergleicht die ersten Elemente und nur wenn diese äquivalent sind, werden die zweiten Elemente verglichen. Das Verhalten ist undefiniert, wenn Typ und Wertkategorie von einem der lhs.first < rhs.first, rhs.first < lhs.first, oder lhs.second < rhs.second nicht die BooleanTestable-Anforderungen erfüllen.

7) Vergleicht lhs und rhs lexikographisch mittels synth-three-way, d.h. vergleicht die ersten Elemente und nur wenn diese äquivalent sind, werden die zweiten Elemente verglichen. synth-three-way-result ist der Rückgabetyp von synth-three-way.

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

(seit C++20)

Parameter

lhs, rhs

-

zu vergleichende Paare

Rückgabewert

1) true, wenn sowohl lhs.first == rhs.first als auch lhs.second == rhs.second, andernfalls false.

2) !(lhs == rhs)

3) Wenn lhs.first < rhs.first, wird true zurückgegeben. Andernfalls, wenn rhs.first < lhs.first, wird false zurückgegeben. Andernfalls, wenn lhs.second < rhs.second, wird true zurückgegeben. Andernfalls wird false zurückgegeben.

4) !(rhs < lhs)

5) rhs < lhs

6) !(lhs < rhs)

7) synth-three-way(lhs.first, rhs.first), wenn dieses nicht gleich ​0​ ist, andernfalls synth-three-way(lhs.second, rhs.second).

Hinweise

Die relationalen Operatoren sind über die operator< jedes Elements 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 ein Elementtyp nicht selbst operator<=> bereitstellt, aber implizit in einen dreistufig vergleichbaren Typ konvertiert werden kann, wird diese Konvertierung anstelle von operator< verwendet.	(seit C++20)

Feature-Test-Makro	Wert	Std	Feature
__cpp_lib_constrained_equality	202403L	(C++26)	Beschränkter operator== für std::pair

Beispiel

Da operator< für Paare definiert ist, können Container von Paaren sortiert werden.

Führen Sie diesen Code aus

#include <algorithm>
#include <iomanip>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
 
int main()
{
    std::vector<std::pair<int, std::string>> v = {{2, "baz"}, {2, "bar"}, {1, "foo"}};
    std::sort(v.begin(), v.end());
 
    for (auto p : v)
        std::cout << '{' << p.first << ", " << std::quoted(p.second) << "}\n";
}

Ausgabe

{1, "foo"}
{2, "bar"}
{2, "baz"}

Berichte über Fehler

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 296	C++98	die Beschreibungen von Operatoren außer == und < fehlten	hinzugefügt
LWG 2114 (P2167R3)	C++98	Typvoraussetzungen für boolesche Operationen fehlten	hinzugefügt
LWG 3865	C++98	Vergleichsoperatoren akzeptierten nur `pair`s desselben Typs	akzeptieren `pair`s unterschiedlicher Typen

Siehe auch

operator==operator!=operator<operator<=operator>operator>=operator<=> (entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(entfernt in C++20)(C++20)

vergleicht die Werte im Tupel lexikographisch (function template)