Namespaces
Variants

operator== (std::expected)

From cppreference.net
C++
Utilities library
std::expected
Plantilla principal
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) (desde C++23)
template < class E2 >

friend constexpr bool operator == ( const expected & lhs,

const std:: unexpected < E2 > & unex ) ;
(2) (desde C++23)
template < class T2 >
friend constexpr bool operator == ( const expected & lhs, const T2 & val ) ;
(3) (desde C++23)
void Especialización parcial
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) (desde C++23)
template < class E2 >

friend constexpr bool operator == ( const expected & lhs,

const std:: unexpected < E2 > & unex ) ;
(5) (desde C++23)

Realiza operaciones de comparación en std::expected objetos.

1) Compara dos objetos std::expected . Los objetos son iguales si y solo si tanto lhs como rhs contienen valores esperados que son iguales, o ambos contienen valores inesperados que son iguales.

Si alguna de las siguientes expresiones está mal formada, o su resultado no es convertible a bool , el programa está mal formado:

(until C++26)

Esta sobrecarga participa en la resolución de sobrecarga solo si todas las siguientes expresiones están bien formadas, y sus resultados son convertibles a bool :

(since C++26)
  • * lhs == * rhs
  • lhs. error ( ) == rhs. error ( )
2) Compara un objeto std::expected con un objeto std::unexpected . Los objetos son iguales si y solo si lhs contiene un valor inesperado que es igual a unex. error ( ) .

Si la expresión lhs. error ( ) == unex. error ( ) está mal formada, o su resultado no es convertible a bool , el programa está mal formado.

(hasta C++26)

Esta sobrecarga participa en la resolución de sobrecarga solo si la expresión lhs. error ( ) == unex. error ( ) está bien formada, y su resultado es convertible a bool .

(desde C++26)
3) Compara un objeto std::expected con un valor esperado. Los objetos son iguales si y solo si lhs contiene un valor esperado que es igual a val .

Si la expresión * lhs == val está mal formada, o su resultado no es convertible a bool , el programa está mal formado.

(hasta C++26)

Esta sobrecarga participa en la resolución de sobrecarga solo si se cumplen todas las siguientes condiciones:

  • T2 no es una especialización de std::expected .
  • La expresión * lhs == val está bien formada, y su resultado es convertible a bool .
(desde C++26)
4) Compara dos objetos std::expected . Los objetos son iguales si y solo si lhs y rhs ambos representan valores esperados, o ambos contienen valores inesperados que son iguales.

Si la expresión lhs. error ( ) == rhs. error ( ) está mal formada, o su resultado no es convertible a bool , el programa está mal formado.

(hasta C++26)

Esta sobrecarga participa en la resolución de sobrecarga solo si la expresión lhs. error ( ) == rhs. error ( ) está bien formada, y su resultado es convertible a bool .

(desde C++26)
5) Compara un objeto std::expected con un objeto std::unexpected . Los objetos son iguales si y solo si lhs contiene un valor inesperado que es igual a unex. error ( ) .

Si la expresión lhs. error ( ) == unex. error ( ) está mal formada, o su resultado no es convertible a bool , el programa está mal formado.

(hasta C++26)

Esta sobrecarga participa en la resolución de sobrecarga solo si la expresión lhs. error ( ) == unex. error ( ) está bien formada, y su resultado es convertible a bool .

(desde C++26)

Estas funciones no son visibles para la búsqueda unqualified o qualified ordinaria, y solo pueden ser encontradas mediante argument-dependent lookup cuando std::expected<T, E> es una clase asociada de los argumentos.

El operador != es sintetizado a partir de operator== .

Contenidos

Parámetros

lhs, rhs - std::expected objeto(s) a comparar
unex - std::unexpected valor a comparar con lhs
val - valor a comparar con el valor esperado contenido en lhs

Valor de retorno

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

Excepciones

Lanza cuando y lo que la comparación lanza.

Notas

Macro de prueba de características Valor Std Característica
__cpp_lib_constrained_equality 202411L (C++26) operadores de comparación restringidos para std::expected

Ejemplo

Ejecutar este código 
#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";
}

Salida: 

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

Véase también

(C++23)
compara std::unexpected objetos
(plantilla de función)