operator==<small>(std::expected)</small>

 

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

Memberfunktionen

expected::expected

expected::~expected

expected::operator=

Observer

expected::operator->expected::operator*

expected::operator boolexpected::has_value

expected::value

expected::error

expected::value_or

expected::error_or

Monadische Operationen

expected::and_then

expected::or_else

expected::transform

expected::transform_error

Modifizierer

expected::emplace

expected::swap

Nicht-Member-Funktionen

operator==(std::expected)

swap(std::expected)

Hilfsklassen

unexpected

bad_expected_access

unexpect_tunexpect

 

Primäre Vorlage
template< class T2, class E2 >   requires (!std::is_void_v<T2>) friend constexpr bool operator==( const expected& lhs,                                   const std::expected<T2, E2>& rhs );	(1)	(seit C++23)
template< class E2 > friend constexpr bool operator==( const expected& lhs,                                   const std::unexpected<E2>& unex );	(2)	(seit C++23)
template< class T2 > friend constexpr bool operator==( const expected& lhs, const T2& val );	(3)	(seit C++23)
void partielle Spezialisierung
template< class T2, class E2 >   requires std::is_void_v<T2> friend constexpr bool operator==( const expected& lhs,                                   const std::expected<T2, E2>& rhs );	(4)	(seit C++23)
template< class E2 > friend constexpr bool operator==( const expected& lhs,                                   const std::unexpected<E2>& unex );	(5)	(seit C++23)

Führt Vergleichsoperationen auf std::expected Objekten durch.

1) Vergleicht zwei std::expected Objekte. Die Objekte sind gleich, wenn und nur wenn sowohl lhs als auch rhs erwartete Werte enthalten, die gleich sind, oder beide unerwartete Werte enthalten, die gleich sind.

Wenn einer der folgenden Ausdrücke fehlerhaft ist oder sein Ergebnis nicht nach bool konvertierbar ist, ist das Programm fehlerhaft	(bis C++26)
Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn alle folgenden Ausdrücke wohlgeformt sind und ihre Ergebnisse nach bool konvertierbar sind	(seit C++26)

• *lhs == *rhs
• lhs.error() == rhs.error()

2) Vergleicht ein std::expected Objekt mit einem std::unexpected Objekt. Die Objekte sind gleich, wenn und nur wenn lhs einen unerwarteten Wert enthält, der gleich unex.error() ist.

Wenn der Ausdruck lhs.error() == unex.error() fehlerhaft ist oder sein Ergebnis nicht nach bool konvertierbar ist, ist das Programm fehlerhaft.	(bis C++26)
Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn der Ausdruck lhs.error() == unex.error() wohlgeformt ist und sein Ergebnis nach bool konvertierbar ist.	(seit C++26)

3) Vergleicht ein std::expected Objekt mit einem erwarteten Wert. Die Objekte sind gleich, wenn und nur wenn lhs einen erwarteten Wert enthält, der gleich val ist.

Wenn der Ausdruck *lhs == val fehlerhaft ist oder sein Ergebnis nicht nach bool konvertierbar ist, ist das Programm fehlerhaft.	(bis C++26)
Dieser Überladung nimmt nur an der Überladungsauflösung teil, wenn alle folgenden Bedingungen erfüllt sind: T2 ist keine Spezialisierung von std::expected. Der Ausdruck *lhs == val ist wohlgeformt und sein Ergebnis ist nach bool konvertierbar.	(seit C++26)

4) Vergleicht zwei std::expected Objekte. Die Objekte sind gleich, wenn und nur wenn lhs und rhs beide erwartete Werte darstellen, oder beide unerwartete Werte enthalten, die gleich sind.

Wenn der Ausdruck lhs.error() == rhs.error() fehlerhaft ist oder sein Ergebnis nicht nach bool konvertierbar ist, ist das Programm fehlerhaft.	(bis C++26)
Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn der Ausdruck lhs.error() == rhs.error() wohlgeformt ist und sein Ergebnis nach bool konvertierbar ist.	(seit C++26)

5) Vergleicht ein std::expected Objekt mit einem std::unexpected Objekt. Die Objekte sind gleich, wenn und nur wenn lhs einen unerwarteten Wert enthält, der gleich unex.error() ist.

Wenn der Ausdruck lhs.error() == unex.error() fehlerhaft ist oder sein Ergebnis nicht nach bool konvertierbar ist, ist das Programm fehlerhaft.	(bis C++26)
Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn der Ausdruck lhs.error() == unex.error() wohlgeformt ist und sein Ergebnis nach bool konvertierbar ist.	(seit C++26)

Diese Funktionen sind für die normale unqualifizierte oder qualifizierte Suche nicht sichtbar und können nur durch argumentabhängige Suche gefunden werden, wenn std::expected<T, E> eine zu den Argumenten assoziierte Klasse ist.

Der Operator != wird aus operator== synthetisiert.

Parameter

lhs, rhs	-	std::expected Objekt(e) zum Vergleichen
unex	-	std::unexpected Wert, mit dem lhs verglichen wird
val	-	Wert, mit dem der erwartete Wert in lhs verglichen wird

Rückgabewert

1) lhs.has_value() != rhs.has_value() ? false :
    (lhs.has_value() ? *lhs == *rhs : lhs.error() == rhs.error())

2) !lhs.has_value() && static_cast<bool>(lhs.error() == unex.error())

3) lhs.has_value() && static_cast<bool>(*lhs == val)

4) lhs.has_value() != rhs.has_value() ? false :
    lhs.has_value() || static_cast<bool>(lhs.error() == rhs.error())

5) !lhs.has_value() && static_cast<bool>(lhs.error() == unex.error())

Ausnahmen

Wirft, wann und welche Ausnahme der Vergleich auslöst.

Hinweise

Feature-Test-Makro	Wert	Std	Feature
__cpp_lib_constrained_equality	202411L	(C++26)	beschränkte Vergleichsoperatoren für std::expected

Beispiel

Führen Sie diesen Code aus

#include <expected>
#include <iostream>
#include <string_view>
 
using namespace std::string_view_literals;
 
int main()
{
    auto x1{"\N{GREEN HEART}"sv};
    auto x2{"\N{CROSS MARK}"sv};
    std::expected<std::string_view, int> e1{x1}, e2{x1}, e3{x2};
    std::unexpected u1{13};
 
    std::cout << "Overload (1):\n"
              << e1.value() << (e1 == e2 ? " == " : " != ") << *e2 << '\n'
              << e1.value() << (e1 != e3 ? " != " : " == ") << *e3 << "\n\n";
 
    std::cout << "Overload (2):\n"
              << e1.value() << (e1 == u1 ? " == " : " != ") << u1.error() << '\n';
    e1 = std::unexpected{13};
    std::cout << e1.error() << (e1 == u1 ? " == " : " != ") << u1.error() << '\n';
    e1 = std::unexpected{31};
    std::cout << e1.error() << (e1 != u1 ? " != " : " == ") << u1.error() << '\n';
 
    std::cout << "Overload (3):\n"
              << *e1 << (e1 == x1 ? " == " : " != ") << x1 << '\n'
              << *e1 << (e1 != x2 ? " != " : " == ") << x2 << "\n\n";
}

Ausgabe

Overload (1):
💚 == 💚
💚 != ❌
 
Overload (2):
💚 != 13
13 == 13
31 != 13
 
Overload (3):
💚 == 💚
💚 != ❌

Siehe auch

unexpected (C++23)

als unerwarteter Wert dargestellt (Klassenschablone)