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

 

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

Memberfunktionen

variant::variant

variant::~variant

variant::operator=

Observer

variant::index

variant::valueless_by_exception

Modifizierer

variant::emplace

variant::swap

Besuch

variant::visit (C++26)

Nicht-Member-Funktionen

visit(std::variant)

holds_alternative

get(std::variant)

get_if

operator==operator!=operator<operator<=operator>operator>=operator<=> (C++20)

swap(std::variant)

Hilfsklassen

monostate

bad_variant_access

variant_size

variant_alternative

hash<std::variant>

Hilfsobjekte

variant_npos

 

Definiert in der Header-Datei <variant>
template< class... Types > constexpr bool operator==( const std::variant<Types...>& lhs,                            const std::variant<Types...>& rhs );	(1)	(seit C++17)
template< class... Types > constexpr bool operator!=( const std::variant<Types...>& lhs,                            const std::variant<Types...>& rhs );	(2)	(seit C++17)
template< class... Types > constexpr bool operator<( const std::variant<Types...>& lhs,                           const std::variant<Types...>& rhs );	(3)	(seit C++17)
template< class... Types > constexpr bool operator>( const std::variant<Types...>& lhs,                           const std::variant<Types...>& rhs );	(4)	(seit C++17)
template< class... Types > constexpr bool operator<=( const std::variant<Types...>& lhs,                            const std::variant<Types...>& rhs );	(5)	(seit C++17)
template< class... Types > constexpr bool operator>=( const std::variant<Types...>& lhs,                            const std::variant<Types...>& rhs );	(6)	(seit C++17)
template< class... Types > constexpr std::common_comparison_category_t               <std::compare_three_way_result_t<Types>...>     operator<=>( const std::variant<Types...>& lhs,                  const std::variant<Types...>& rhs );	(7)	(seit C++20)
Helper function template
template< std::size_t I, class... Types > constexpr const std::variant_alternative_t<I, std::variant<Types...>>&     GET( const variant<Types...>& v );	(8)	(nur Exposition*)

Führt Vergleichsoperationen für std::variant-Objekte durch.

1-7) Vergleicht zwei std::variant-Objekte lhs und rhs. Die enthaltenen Werte werden verglichen (unter Verwendung des entsprechenden Operators von T), nur wenn sowohl lhs als auch rhs Werte enthalten, die dem gleichen Index entsprechen. Andernfalls,

• lhs ist *gleich* rhs genau dann, wenn weder lhs noch rhs einen Wert enthalten.
• lhs wird als *kleiner als* rhs betrachtet, wenn und nur wenn entweder rhs einen Wert enthält und lhs nicht, oder lhs.index() kleiner ist als rhs.index().

1-6) Sei @ der entsprechende Vergleichsoperator, für jede dieser Funktionen

Wenn für einige Werte von I der entsprechende Ausdruck GET <I>(lhs) @ GET <I>(rhs) nicht wohlgeformt ist oder sein Ergebnis nicht in bool konvertierbar ist, ist das Programm nicht wohlgeformt.	(bis C++26)
Diese Überladung nimmt an der Überladungsauflösung teil, nur wenn für alle Werte von I der entsprechende Ausdruck GET <I>(lhs) @ GET <I>(rhs) wohlgeformt ist und sein Ergebnis in bool konvertierbar ist.	(seit C++26)

8) Die exposition-only-Funktionsvorlage GET verhält sich wie std::get(std::variant), mit der Ausnahme, dass std::bad_variant_access nie geworfen wird.

Wenn I < sizeof...(Types) false ist, ist das Programm nicht wohlgeformt.

Wenn I == v.index() false ist, ist das Verhalten undefiniert.

Parameter

lhs,rhs

-

Zu vergleichende variants

Rückgabewert

Operator	Beide Operanden enthalten einen Wert (sei I lhs.index() und J rhs.index())		lhs oder rhs ist wertlos (sei lhs_empty lhs.valueless_by_exception() und rhs_empty rhs.valueless_by_exception())
	I und J sind gleich	I und J sind ungleich
==	GET <I>(lhs) == GET <I>(rhs)	false	lhs_empty && rhs_empty
!=	GET <I>(lhs) != GET <I>(rhs)	true	lhs_empty != rhs_empty
<	GET <I>(lhs) < GET <I>(rhs)	lhs.index() < rhs.index()	lhs_empty && !rhs_empty
>	GET <I>(lhs) > GET <I>(rhs)	lhs.index() > rhs.index()	!lhs_empty && rhs_empty
<=	GET <I>(lhs) <= GET <I>(rhs)	lhs.index() < rhs.index()	lhs_empty
>=	GET <I>(lhs) >= GET <I>(rhs)	lhs.index() > rhs.index()	rhs_empty
<=>	GET <I>(lhs) <=> GET <I>(rhs)	lhs.index() <=> rhs.index()	siehe unten

Für operator<=>

• Wenn nur lhs wertlos ist, gibt std::strong_ordering::less zurück.
• Wenn nur rhs wertlos ist, gibt std::strong_ordering::greater zurück.
• Wenn sowohl lhs als auch rhs wertlos sind, gibt std::strong_ordering::equal zurück.

Anmerkungen

Feature-Test-Makro	Wert	Std	Feature
__cpp_lib_constrained_equality	202403L	(C++26)	eingeschränkte Vergleichsoperatoren für std::variant

Beispiel

Führen Sie diesen Code aus

#include <iostream>
#include <string>
#include <variant>
 
int main()
{
    std::cout << std::boolalpha;
    std::string cmp;
    bool result;
 
    auto print2 = [&cmp, &result](const auto& lhs, const auto& rhs)
    {
        std::cout << lhs << ' ' << cmp << ' ' << rhs << " : " << result << '\n';
    };
 
    std::variant<int, std::string> v1, v2;
 
    std::cout << "operator==\n";
    {
        cmp = "==";
 
        // by default v1 = 0, v2 = 0;
        result = v1 == v2; // true
        std::visit(print2, v1, v2);
 
        v1 = v2 = 1;
        result = v1 == v2; // true
        std::visit(print2, v1, v2);
 
        v2 = 2;
        result = v1 == v2; // false
        std::visit(print2, v1, v2);
 
        v1 = "A";
        result = v1 == v2; // false: v1.index == 1, v2.index == 0
        std::visit(print2, v1, v2);
 
        v2 = "B";
        result = v1 == v2; // false
        std::visit(print2, v1, v2);
 
        v2 = "A";
        result = v1 == v2; // true
        std::visit(print2, v1, v2);
    }
 
    std::cout << "operator<\n";
    {
        cmp = "<";
 
        v1 = v2 = 1;
        result = v1 < v2; // false
        std::visit(print2, v1, v2);
 
        v2 = 2;
        result = v1 < v2; // true
        std::visit(print2, v1, v2);
 
        v1 = 3;
        result = v1 < v2; // false
        std::visit(print2, v1, v2);
 
        v1 = "A"; v2 = 1;
        result = v1 < v2; // false: v1.index == 1, v2.index == 0
        std::visit(print2, v1, v2);
 
        v1 = 1; v2 = "A";
        result = v1 < v2; // true: v1.index == 0, v2.index == 1
        std::visit(print2, v1, v2);
 
        v1 = v2 = "A";
        result = v1 < v2; // false
        std::visit(print2, v1, v2);
 
        v2 = "B";
        result = v1 < v2; // true
        std::visit(print2, v1, v2);
 
        v1 = "C";
        result = v1 < v2; // false
        std::visit(print2, v1, v2);
    }
 
    {
        std::variant<int, std::string> v1;
        std::variant<std::string, int> v2;
    //  v1 == v2; // Compilation error: no known conversion
    }
 
    // TODO: C++20 three-way comparison operator <=> for variants
}

Ausgabe

operator==
0 == 0 : true
1 == 1 : true
1 == 2 : false
A == 2 : false
A == B : false
A == A : true
operator<
1 < 1 : false
1 < 2 : true
3 < 2 : false
A < 1 : false
1 < A : true
A < A : false
A < B : true
C < B : false

Siehe auch

operator==operator!=operator<operator<=operator>operator>=operator<=> (C++17)(C++17)(C++17)(C++17)(C++17)(C++17)(C++20)

vergleicht optional-Objekte (function template)