Namespaces
Variants

    operator==(std::expected)

    De es.cppreference.net
     
    C++
    Soporte de compiladores
    Independiente y alojado
    Lenguaje
    Biblioteca estándar
    Encabezados de la biblioteca estándar
    Requisitos nombrados
    Macros de prueba de características (C++20)
    Biblioteca de soporte del lenguaje
    Biblioteca de conceptos (C++20)
    Biblioteca de diagnóstico
    Biblioteca de gestión de memoria
    Biblioteca de metaprogramación (C++11)
    Biblioteca de utilidades generales
    Biblioteca de contenedores
    Biblioteca de iteradores
    Biblioteca de rangos (C++20)
    Biblioteca de algoritmos
    Biblioteca de cadenas
    Biblioteca de procesamiento de texto
    Biblioteca numérica
    Biblioteca de fecha y hora
    Biblioteca de entrada/salida
    Biblioteca del sistema de archivos (C++17)
    Biblioteca de soporte de concurrencia (C++11)
    Biblioteca de control de ejecución (C++26)
    Especificaciones técnicas
    Índice de símbolos
    Bibliotecas externas
     
    Biblioteca de utilidades
    Soporte del lenguaje
    Soporte de tipos (tipos básicos, RTTI)
    Macros de prueba de características de biblioteca (C++20)
    Utilidades de programa
    Funciones variádicas
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Soporte de corrutinas (C++20)
    Soporte de contratos (C++26)
    Comparación de tres vías
    (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)

    Utilidades generales
    Operadores relacionales (obsoleto en C++20)
     
    std::expected
     
    Plantilla primaria
    		 
    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 objetos std::expected.

    1) Compara dos objetos std::expected. Los objetos se comparan iguales si y solo si ambos lhs y 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:

    		(hasta 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:

    		(desde C++26)
    • *lhs == *rhs
    • lhs.error() == rhs.error()
    2) Compara un objeto std::expected con un objeto std::unexpected. Los objetos se comparan 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 se comparan 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 satisfacen 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 se comparan 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 se comparan 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 no calificada o búsqueda calificada ordinarias, y solo se pueden encontrar mediante búsqueda dependiente de argumentos cuando std::expected<T, E> es una clase asociada de los argumentos.

    El operador != se sintetiza a partir de operator==.

    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)