Namespaces
Variants

operator== (std::expected)

From cppreference.net
C++
Utilities library
std::expected
Primäres Template
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 aus.

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

Falls einer der folgenden Ausdrücke ill-formed ist oder sein Ergebnis nicht in bool konvertierbar ist, ist das Programm ill-formed:

(bis C++26)

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

Falls der Ausdruck lhs. error ( ) == unex. error ( ) fehlerhaft ist oder sein Ergebnis nicht in bool konvertierbar ist, ist das Programm fehlerhaft.

(bis C++26)

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

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

Falls der Ausdruck * lhs == val nicht wohlgeformt ist oder sein Ergebnis nicht in bool konvertierbar ist, ist das Programm nicht wohlgeformt.

(bis C++26)

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

Falls der Ausdruck lhs. error ( ) == rhs. error ( ) ill-formed ist oder sein Ergebnis nicht in bool konvertierbar ist, ist das Programm ill-formed.

(bis C++26)

Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn der Ausdruck lhs. error ( ) == rhs. error ( ) well-formed 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 genau dann gleich, wenn lhs einen unerwarteten Wert enthält, der gleich unex. error ( ) ist.

Falls der Ausdruck lhs. error ( ) == unex. error ( ) fehlerhaft ist oder sein Ergebnis nicht in bool konvertierbar ist, ist das Programm fehlerhaft.

(bis C++26)

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

(seit C++26)

Diese Funktionen sind für gewöhnliches unqualified oder qualified lookup nicht sichtbar und können nur durch argument-dependent lookup gefunden werden, wenn std::expected<T, E> eine assoziierte Klasse der Argumente ist.

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

Inhaltsverzeichnis

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)