Namespaces
Variants

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

From cppreference.net
C++
Utilities library
std::pair
Member functions
(C++11)
Non-member functions
operator== operator!= operator< operator<= operator> operator>= operator<=>
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20) (C++20)
(C++11)
(C++11)
Helper classes
(C++11)
(C++11)
(C++23)
(C++23)
(C++23)
(C++11)
Deduction guides (C++17)
Definiert im Header <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, das heißt, 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 die BooleanTestable -Anforderungen nicht erfüllen.

(bis C++26)

Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn sowohl decltype ( lhs. first == rhs. first ) als auch decltype ( lhs. second == rhs. second ) das Konzept boolean-testable modellieren.

(seit C++26)
3-6) Vergleicht lhs und rhs lexikografisch mittels operator < , das heißt, vergleicht die ersten Elemente und nur wenn diese äquivalent sind, vergleicht es die zweiten Elemente. Das Verhalten ist undefiniert, wenn der Typ und die Wertkategorie von lhs. first < rhs. first , rhs. first < lhs. first , oder lhs. second < rhs. second die BooleanTestable -Anforderungen nicht erfüllen.
7) Vergleicht lhs und rhs lexikographisch mittels synth-three-way , das heißt, vergleicht die ersten Elemente und nur wenn diese äquivalent sind, vergleicht es die zweiten Elemente. synth-three-way-result ist der Rückgabetyp von synth-three-way .

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

(seit C++20)

Inhaltsverzeichnis

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 ) falls es nicht gleich ​ 0 ​ ist, andernfalls synth-three-way ( lhs. second , rhs. second ) .

Hinweise

Die relationalen Operatoren werden anhand des operator < jedes Elements definiert.

(bis C++20)

Die relationalen Operatoren werden anhand von synth-three-way definiert, das operator <=> verwendet, falls möglich, andernfalls operator < .

Insbesondere, wenn ein Elementtyp selbst keinen operator <=> bereitstellt, aber implizit in einen dreiweg-vergleichbaren Typ konvertierbar ist, wird diese Konvertierung anstelle von operator < verwendet.

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

Beispiel

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

Code ausführen 
#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"}

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

Siehe auch

(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
(Funktions-Template)