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

 

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::tuple

Memberfunktionen

tuple::tuple

tuple::operator=

tuple::swap

Nicht-Member-Funktionen

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)

Hilfskonzepte

tuple-ähnlich (C++23)

Hilfsklassen

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)

ignorieren

Deduktions-Guides(C++17)

 

Definiert in der Header-Datei <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 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 ein i in [​0​, sizeof...(Types)) kein gültiger Ausdruck ist, ist das Programm schlecht formatiert. Wenn der Typ und die Wertkategorie von std::get<i>(lhs) == std::get<i>(rhs) für ein i in [​0​, sizeof...(Types)) die BooleanTestable-Anforderungen nicht erfüllen, ist das Verhalten undefiniert.	(bis C++26)
Diese Überladung nimmt nur an der Overload-Auflö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)) für jedes i in [​0​, sizeof...(Types)) die boolean-testable-Bedingungen erfüllt.	(seit C++26)

3-6) Vergleicht lhs und rhs lexikographisch mittels operator<, d.h., vergleicht das erste Element, falls diese gleich sind, vergleicht das zweite Element, falls diese gleich sind, vergleicht das dritte Element, und so weiter.

3) Für leere Tupel gibt es false zurück. Für nicht-leere Tupel ist die Auswirkung äquivalent zu
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 äquivalenten Anweisungen kein gültiger Ausdruck ist, ist das Programm schlecht formatiert.

Wenn der Typ und die Wertkategorie eines beliebigen Vergleichsausdrucks in den äquivalenten Anweisungen die BooleanTestable-Anforderungen nicht erfüllen, ist das Verhalten undefiniert.

7) Vergleicht lhs und rhs lexikographisch mittels synth-three-way, d.h., vergleicht das erste Element, falls diese gleich sind, vergleicht das zweite Element, falls diese gleich sind, vergleicht das dritte Element, und so weiter.

• Für leere Tupel wird std::strong_ordering::equal zurückgegeben.
• Für nicht-leere Tupel ist die Auswirkung äquivalent zu

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) Wie (1), jedoch ist rhs ein tuple-like-Objekt und die Anzahl der Elemente von rhs wird stattdessen durch std::tuple_size_v<UTuple> bestimmt. Diese Überladung kann nur über argumentabhängige Auflösung gefunden werden.

9) Wie (7), jedoch ist rhs ein tuple-like-Objekt. /* Elems */ bezeichnet die Packung von Typen std::tuple_element_t<i, UTuple> für jedes i in aufsteigender Reihenfolge in [​0​, std::tuple_size_v<UTuple>). Diese Überladung kann nur über argumentabhängige Auflösung gefunden werden.

Alle Vergleichsoperatoren werden kurzgeschlossen; sie greifen nicht auf Tupel-Elemente zu, die über das für die Bestimmung des Vergleichsergebnisses Notwendige hinausgehen.

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

(seit C++20)

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)) gilt, 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 in rhs, false, wenn das erste nicht-äquivalente Element in rhs kleiner ist als das in lhs oder wenn kein nicht-äquivalentes Element vorhanden ist. Für zwei leere Tupel wird false zurückgegeben.

4) !(rhs < lhs)

5) rhs < lhs

6) !(lhs < rhs)

7,9) Die Relation zwischen dem ersten Paar nicht-äquivalenter Elemente, falls vorhanden, andernfalls std::strong_ordering::equal. Für zwei leere Tupel wird std::strong_ordering::equal zurückgegeben.

Hinweise

Die relationalen Operatoren sind in Bezug auf den 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 dreiwertig vergleichbaren Typ konvertierbar ist, wird diese Konvertierung anstelle von operator< verwendet.	(seit C++20)

Feature-Test-Makro	Wert	Std	Feature
__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.

Führen Sie diesen Code aus

#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 }

Meldungen

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 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 (Funktionsvorlage)