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

Definiert in 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, /* Elems */>...> 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 korrespondierender Elemente gleich sind.

2) Gibt !(lhs == rhs) zurück.

Wenn sizeof...(TTypes) nicht gleich sizeof...(UTypes) ist oder std::get(lhs) == std::get(rhs) kein gültiger Ausdruck für irgendein i in [0, sizeof...(Types)) ist, ist das Programm fehlerhaft.

Wenn der Typ und die Wertkategorie von std::get(lhs) == std::get(rhs) für irgendein in die iBooleanTestable[0, sizeof...(Types))-Anforderungen nicht erfüllen, ist das Verhalten undefiniert.

(bis C++26)

Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn sizeof...(TTypes) gleich sizeof...(UTypes) ist, std::get(lhs) == std::get(rhs) ein gültiger Ausdruck ist und decltype(std::get(lhs) == std::get(rhs)) für jedes in das iboolean-testable[0, sizeof...(Types))-Konzept modelliert.

(seit C++26)

3-6) Vergleicht lhs und rhs lexikografisch mittels operator<, das heißt, vergleicht die ersten Elemente, falls diese äquivalent sind, vergleicht die zweiten Elemente, falls auch 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 die Wirkung

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 irgendeiner der in den Equivalent-to-Anweisungen gezeigten Vergleichsausdrücke kein gültiger Ausdruck ist, ist das Programm fehlerhaft.

Wenn der Typ und die Wertkategorie irgendeines der in den Equivalent-to-Anweisungen gezeigten Vergleichsausdrücke die BooleanTestable-Anforderungen nicht erfüllen, ist das Verhalten undefiniert.

7) Vergleicht lhs und rhs lexikografisch mittels synth-three-way, das heißt, vergleicht die ersten Elemente, falls diese äquivalent sind, vergleicht die zweiten Elemente, falls auch diese äquivalent sind, vergleicht die dritten Elemente, und so weiter.

Für leere Tupel wird std::strong_ordering::equal zurückgegeben.
Für nicht-leere Tupel entspricht die Wirkung

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) Gleichwertig zu (1), außer dass rhs ein tuple-like-Objekt ist und die Anzahl der Elemente von rhs stattdessen durch std::tuple_size_v<UTuple> bestimmt wird. Diese Überladung kann nur über argumentabhängige Namenssuche gefunden werden.

9) Gleichwertig zu (7), außer dass rhs ein tuple-like-Objekt ist. /* Elems */ bezeichnet das Paket von 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 kurzschließend; sie greifen nicht auf Tupelelemente zu, die über das zur Bestimmung des Vergleichsergebnisses Notwendige hinausgehen.

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

(seit C++20)

Parameter

lhs, rhs

-

zu vergleichende Tupel

Rückgabewert

1,8) true wenn std :: get ( lhs ) == std :: get ( 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

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


          pair

lexikographisch
(Funktionstemplate)

Compilerunterstützung
Freistehend und gehostet
Sprache
Standardbibliothek
Header der Standardbibliothek
Benannte Anforderungen
Feature-Test-Makros (C++20)
Sprachunterstützungsbibliothek
Konzeptbibliothek (C++20)
Diagnosebibliothek
Speicherverwaltungsbibliothek
Metaprogrammierungsbibliothek (C++11)
Allgemeine Dienstprogrammbibliothek
Containerbibliothek
Iteratorenbibliothek
Ranges-Bibliothek (C++20)
Algorithmenbibliothek
Zeichenkettenbibliothek
Textverarbeitungsbibliothek
Numerikbibliothek
Datums- und Zeitbibliothek
Ein-/Ausgabebibliothek
Dateisystembibliothek (C++17)
Nebenläufigkeitsunterstützungsbibliothek (C++11)
Ausführungssteuerungsbibliothek (C++26)
Technische Spezifikationen
Symbolverzeichnis
Externe Bibliotheken

Mitgliedsfunktionen
tuple::tuple
tuple::operator=
tuple::swap
Nicht-Mitgliedsfunktionen
make_tuple
tie
forward_as_tuple
tuple_cat
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::tuple)
get(std::tuple)
Helfer-Konzepte
`tuple-like` (C++23)
Helfer-Klassen
tuple_size<std::tuple>
tuple_element<std::tuple>
uses_allocator<std::tuple>
basic_common_reference<std::tuple> (C++23)
common_type<std::tuple> (C++23)
formatter<std::tuple> (C++23)
ignore
Ableitungsregeln(C++17)

de.cppreference.net

Namespaces

Variants