Namespaces
Variants

    operator==(std::expected)

    Aus de.cppreference.net
     
    C++
     
    Dienstprogrammbibliothek
    Sprachunterstützung
    Typunterstützung (grundlegende Typen, RTTI)
    Bibliotheks-Feature-Test-Makros (C++20)
    Programmdienstprogramme
    Variadische Funktionen
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Koroutinen-Unterstützung (C++20)
    Vertragsunterstützung (C++26)
    Dreiseitiger Vergleich
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Allgemeine Dienstprogramme
    Relationale Operatoren (veraltet in C++20)
    Ganzzahl-Vergleichsfunktionen
    (C++20)(C++20)(C++20)    
    (C++20)
    Swap und Typoperationen
    (C++20)
    (C++14)
    (C++11)
    (C++23)
    (C++11)
    (C++23)
    (C++11)
    (C++11)
    (C++17)
    Allgemeine Vokabeltypen
    (C++11)
    (C++17)
    (C++17)
    (C++17)
    (C++11)
    (C++11)
    (C++17)
    (C++17)
    (C++23)



     
    std::expected
     
    Primäre Schablone
    		 
    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 mit std::expected-Objekten durch.

    1) Vergleicht zwei std::expected-Objekte. Die Objekte sind gleich genau dann, wenn beide lhs und rhs erwartete Werte enthalten, die gleich sind, oder beide unerwartete Werte enthalten, die gleich sind.

    Wenn einer der folgenden Ausdrücke ungültig ist oder sein Ergebnis nicht in bool konvertierbar ist, ist das Programm ungültig:

    		(bis C++26)

    Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn alle folgenden Ausdrücke gültig sind und ihre Ergebnisse in 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 genau dann, wenn lhs einen unerwarteten Wert enthält, der gleich unex.error() ist.

    Wenn der Ausdruck lhs.error() == unex.error() ungültig ist oder sein Ergebnis nicht in bool konvertierbar ist, ist das Programm ungültig.

    		(bis C++26)

    Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn der Ausdruck lhs.error() == unex.error() gültig ist und sein Ergebnis in bool konvertierbar ist.

    		(seit C++26)
    3) Vergleicht ein std::expected-Objekt mit einem erwarteten Wert. Die Objekte sind gleich genau dann, wenn lhs einen erwarteten Wert enthält, der gleich val ist.

    Wenn der Ausdruck *lhs == val ungültig ist oder sein Ergebnis nicht in bool konvertierbar ist, ist das Programm ungültig.

    		(bis C++26)

    Diese Ü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 gültig und sein Ergebnis ist in bool konvertierbar.
    		 (seit C++26)
    4) Vergleicht zwei std::expected-Objekte. Die Objekte sind gleich genau dann, wenn lhs und rhs beide erwartete Werte darstellen oder beide unerwartete Werte enthalten, die gleich sind.

    Wenn der Ausdruck lhs.error() == rhs.error() ungültig ist oder sein Ergebnis nicht in bool konvertierbar ist, ist das Programm ungültig.

    		(bis C++26)

    Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn der Ausdruck lhs.error() == rhs.error() gültig ist und sein Ergebnis in bool konvertierbar ist.

    		(seit C++26)
    5) Vergleicht ein std::expected-Objekt mit einem std::unexpected-Objekt. Die Objekte sind gleich genau dann, wenn lhs einen unerwarteten Wert enthält, der gleich unex.error() ist.

    Wenn der Ausdruck lhs.error() == unex.error() ungültig ist oder sein Ergebnis nicht in bool konvertierbar ist, ist das Programm ungültig.

    		(bis C++26)

    Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn der Ausdruck lhs.error() == unex.error() gültig ist und sein Ergebnis in bool konvertierbar ist.

    		(seit C++26)

    Diese Funktionen sind bei gewöhnlicher unqualifizierter oder qualifizierter Suche nicht sichtbar und können nur durch argumentabhängige Suche gefunden werden, wenn std::expected<T, E> eine assoziierte Klasse der Argumente ist.

    Der !=-Operator wird aus synthetisiert aus operator==.

    Parameter

    lhs, rhs - std::expected Objekt(e) zum Vergleichen
    unex - std::unexpected Wert zum Vergleich mit lhs
    val - Wert zum Vergleich mit dem erwarteten Wert in lhs

    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 aus, wann und was der Vergleich auswirft.

    Hinweise

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

    Beispiel

    Diesen Code ausführen 
    #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

    (C++23)
    		vergleicht std::unexpected Objekte
    (Funktions-Template)