Namespaces
Variants

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

    Aus de.cppreference.net
     
    C++
     
    Hilfsbibliothek
    Sprachunterstützung
    Typunterstützung (Basistypen, RTTI)
    Bibliotheks-Feature-Test-Makros (C++20)
    Programm-Hilfsmittel
    Variadische Funktionen
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Koroutinen-Unterstützung (C++20)
    Vertragsunterstützung (C++26)
    Drei-Wege-Vergleich
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Allgemeine Hilfsmittel
    Relationale Operatoren (veraltet in C++20)
    Ganzzahl-Vergleichsfunktionen
    (C++20)(C++20)(C++20)    
    (C++20)
    Swap und Typ-Operationen
    (C++20)
    (C++14)
    (C++11)
    (C++23)
    (C++11)
    (C++23)
    (C++11)
    (C++11)
    (C++17)
    Allgemeine Vokabular-Typen
    (C++11)
    (C++17)
    (C++17)
    (C++17)
    (C++11)
    (C++11)
    (C++17)
    (C++17)
    (C++23)



     
    std::pair
     
    Definiert in Header <utility> 
    template< class T1, class T2, class U1, class U2 >
bool operator==( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );
    		(1) (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) 
    template< class T1, class T2, class U1, class U2 >
bool operator!=( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );
    		(2) (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 >
bool operator<( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );
    		(3) (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 >
bool operator<=( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );
    		(4) (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 >
bool operator>( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );
    		(5) (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 >
bool operator>=( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );
    		(6) (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) Testet, 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 der Typ und die Wertkategorie von lhs.first == rhs.first oder lhs.second == rhs.second die Anforderungen von BooleanTestable nicht 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) das Konzept boolean-testable modellieren.

    		(seit C++26)
    3-6) Vergleicht lhs und rhs lexikografisch mittels operator<, d.h. vergleicht die ersten Elemente und nur wenn diese äquivalent sind, 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 Anforderungen von BooleanTestable nicht erfüllen.
    7) Vergleicht lhs und rhs lexikografisch mittels synth-three-way, d.h. vergleicht die ersten Elemente und nur wenn diese äquivalent sind, die zweiten Elemente. synth-three-way-result ist der Rückgabetyp von synth-three-way.

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

    		(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 ) 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 lexikografisch die Werte im Tupel
    (Funktionsschablone)