Namespaces
Variants

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

From cppreference.net
C++
Utilities library
std::tuple
(Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags leer sind. Die Struktur wurde originalgetreu beibehalten.)
Definiert im Header <tuple>
template < class ... TTypes , class ... UTypes >

bool operator == ( const std:: tuple < TTypes... > & lhs,

const std:: tuple < UTypes... > & rhs ) ;
(1) (seit C++11)
(constexpr seit C++14)
template < class ... TTypes , class ... UTypes >

bool operator ! = ( const std:: tuple < TTypes... > & lhs,

const std:: tuple < UTypes... > & rhs ) ;
(2) (seit C++11)
(constexpr seit C++14)
(bis C++20)
template < class ... TTypes , class ... UTypes >

bool operator < ( const std:: tuple < TTypes... > & lhs,

const std:: tuple < UTypes... > & rhs ) ;
(3) (seit C++11)
(constexpr seit C++14)
(bis C++20)
template < class ... TTypes , class ... UTypes >

bool operator <= ( const std:: tuple < TTypes... > & lhs,

const std:: tuple < UTypes... > & rhs ) ;
(4) (seit C++11)
(constexpr seit C++14)
(bis C++20)
template < class ... TTypes , class ... UTypes >

bool operator > ( const std:: tuple < TTypes... > & lhs,

const std:: tuple < UTypes... > & rhs ) ;
(5) (seit C++11)
(constexpr seit C++14)
(bis C++20)
template < class ... TTypes , class ... UTypes >

bool operator >= ( const std:: tuple < TTypes... > & lhs,

const std:: tuple < UTypes... > & rhs ) ;
(6) (seit C++11)
(constexpr seit C++14)
(bis C++20)
template < class ... TTypes , class ... UTypes >

constexpr std:: common_comparison_category_t <
synth - three - way - result < TTypes, Elems > ... >
operator <=> ( const std:: tuple < TTypes... > & lhs,

const std:: tuple < UTypes... > & rhs ) ;
(7) (seit C++20)
template < class ... TTypes , tuple - like UTuple >
constexpr bool operator == ( const tuple < TTypes... > & lhs, const UTuple & rhs ) ;
(8) (seit C++23)
template < class ... TTypes , tuple - like UTuple >

constexpr std:: common_comparison_category_t <
synth - three - way - result < TTypes, /* Elemente */ > ... >

operator <=> ( const tuple < TTypes... > & lhs, const UTuple & rhs ) ;
(9) (seit C++23)
1,2) Vergleicht jedes Element des Tupels lhs mit dem entsprechenden Element des Tupels rhs mittels operator == .
1) Gibt true zurück, wenn alle Paare entsprechender Elemente gleich sind.
2) Gibt ! ( lhs == rhs ) zurück.
Wenn sizeof... ( TTypes ) nicht gleich sizeof... ( UTypes ) ist, oder std :: get < i > ( lhs ) == std :: get < i > ( rhs ) für irgendein i in [ ​ 0 ​ , sizeof... ( Types ) ) kein gültiger Ausdruck ist, ist das Programm fehlerhaft.
Wenn der Typ und die Wertkategorie von std :: get < i > ( lhs ) == std :: get < i > ( rhs ) für irgendein i in [ ​ 0 ​ , sizeof... ( Types ) ) nicht die BooleanTestable -Anforderungen erfüllen, ist das Verhalten undefiniert.
(bis C++26)
Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn sizeof... ( TTypes ) gleich sizeof... ( UTypes ) ist, std :: get < i > ( lhs ) == std :: get < i > ( rhs ) ein gültiger Ausdruck ist und decltype ( std :: get < i > ( lhs ) == std :: get < i > ( rhs ) ) das Konzept boolean-testable für jedes i in [ ​ 0 ​ , sizeof... ( Types ) ) modelliert.
(seit C++26)
3-6) Vergleicht lhs und rhs lexikographisch mittels operator < , das heißt, vergleicht die ersten Elemente, wenn diese äquivalent sind, vergleicht die zweiten Elemente, wenn diese äquivalent sind, vergleicht die dritten Elemente, und so weiter.
3) Für leere Tupel wird false zurückgegeben. Für nicht-leere Tupel entspricht der Effekt
if ( std :: get < 0 > ( lhs ) < std :: get < 0 > ( rhs ) ) return true ;

if ( std :: get < 0 > ( rhs ) < std :: get < 0 > ( lhs ) ) return false ;
if ( std :: get < 1 > ( lhs ) < std :: get < 1 > ( rhs ) ) return true ;
if ( std :: get < 1 > ( rhs ) < std :: get < 1 > ( lhs ) ) return false ;
...

return std :: get < N - 1 > ( lhs ) < std :: get < N - 1 > ( rhs ) ;
4) Gibt ! ( rhs < lhs ) zurück.
5) Gibt rhs < lhs zurück.
6) Gibt ! ( lhs < rhs ) zurück.
Wenn sizeof... ( TTypes ) nicht gleich sizeof... ( UTypes ) ist, oder einer der Vergleichsausdrücke in den Equivalent-To-Anweisungen kein gültiger Ausdruck ist, ist das Programm fehlerhaft.
Wenn der Typ und die Wertkategorie eines der Vergleichsausdrücke, die in den equivalent-to-Anweisungen gezeigt werden, nicht den BooleanTestable Anforderungen entsprechen, ist das Verhalten undefiniert.
7) Vergleicht lhs und rhs lexikographisch mittels synth-three-way , das heißt, vergleicht die ersten Elemente, wenn diese äquivalent sind, vergleicht die zweiten Elemente, wenn diese äquivalent sind, vergleicht die dritten Elemente, und so weiter.

if ( auto c = synth-three-way ( std :: get < 0 > ( lhs ) , std :: get < 0 > ( rhs ) ) ; c ! = 0 ) return c ;
if ( auto c = synth-three-way ( std :: get < 1 > ( lhs ) , std :: get < 1 > ( rhs ) ) ; c ! = 0 ) return c ;
...
return synth-three-way ( std :: get < N - 1 > ( lhs ) , std :: get < N - 1 > ( rhs ) ) ;

8) Gleich wie (1) , außer dass rhs ein tuple-like -Objekt ist und die Anzahl der Elemente von rhs durch std:: tuple_size_v < UTuple > bestimmt wird. Diese Überladung kann nur durch argumentabhängige Suche gefunden werden.
9) Gleich wie (7) , außer dass rhs ein tuple-like -Objekt ist. /* Elems */ bezeichnet das Paket der Typen std:: tuple_element_t < i, UTuple > für jedes i in [ ​ 0 ​ , std:: tuple_size_v < UTuple > ) in aufsteigender Reihenfolge. Diese Überladung kann nur über argumentabhängige Namenssuche gefunden werden.

Alle Vergleichsoperatoren sind kurzgeschlossen; sie greifen nicht auf Tupel-Elemente zu, die über das zur Bestimmung des Vergleichsergebnisses notwendige Maß hinausgehen.

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

(since C++20)

Inhaltsverzeichnis

Parameter

lhs, rhs - zu vergleichende Tupel

Rückgabewert

1,8) true wenn std :: get < i > ( lhs ) == std :: get < i > ( rhs ) für alle i in [ ​ 0 ​ , sizeof... ( Types ) ) , andernfalls false . Für zwei leere Tupel wird true zurückgegeben.
2) ! ( lhs == rhs )
3) true wenn das erste nicht-äquivalente Element in lhs kleiner ist als das entsprechende in rhs , false wenn das erste nicht-äquivalente Element in rhs kleiner ist als das entsprechende in lhs oder wenn kein nicht-äquivalentes Element existiert. Für zwei leere Tupel wird false zurückgegeben.
4) ! ( rhs < lhs )
5) rhs < lhs
6) ! ( lhs < rhs )
7,9) Die Beziehung zwischen dem ersten Paar nicht-äquivalenter Elemente, falls vorhanden, std::strong_ordering::equal andernfalls. Für zwei leere Tupel wird std::strong_ordering::equal zurückgegeben.

Hinweise

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

(bis C++20)

Die relationalen Operatoren werden anhand von synth-three-way definiert, welches 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::tuple

Beispiel

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

Code ausführen 
#include <algorithm>
#include <iostream>
#include <tuple>
#include <vector>
int main()
{
    std::vector<std::tuple<int, std::string, float>> v
    {
        {2, "baz", -0.1},
        {2, "bar", 3.14},
        {1, "foo", 10.1},
        {2, "baz", -1.1},
    };
    std::sort(v.begin(), v.end());
    for (const auto& p: v)
        std::cout << "{ " << get<0>(p)
                  << ", " << get<1>(p)
                  << ", " << get<2>(p)
                  << " }\n";
}

Ausgabe: 

{ 1, foo, 10.1 }
{ 2, bar, 3.14 }
{ 2, baz, -1.1 }
{ 2, baz, -0.1 }

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 2114
( P2167R3 ) 		C++11 Typ-Präbedingungen für boolesche Operationen fehlten hinzugefügt

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 pair lexikographisch
(Funktionstemplate)