Namespaces
Variants

std:: unexpected

From cppreference.net
C++
Utilities library
std::expected
Definido en el encabezado <expected>
template < class E >
class unexpected ;
(desde C++23)

La plantilla de clase std::unexpected representa un valor inesperado almacenado en std::expected . En particular, std::expected tiene constructores con std::unexpected como único argumento, lo que crea un objeto expected que contiene un valor inesperado.

Un programa está mal formado si instancia un unexpected con un tipo que no es de objeto, un tipo array, una especialización de std::unexpected , o un tipo con calificadores cv.

Contenidos

Parámetros de plantilla

E - el tipo del valor inesperado. El tipo no debe ser un tipo array, un tipo no-objeto, una especialización de std::unexpected , o un tipo con calificadores cv.

Funciones miembro

construye el objeto unexpected
(función miembro pública)
(destructor)
(implicitly declared)
destruye el objeto unexpected junto con el valor almacenado
(función miembro pública)
operator=
(implicitly declared)
asigna el valor almacenado
(función miembro pública)
accede al valor almacenado
(función miembro pública)
intercambia el valor almacenado
(función miembro pública)

Funciones no miembro

(C++23)
compara el valor almacenado
(plantilla de función)
(C++23)
especializa el algoritmo std::swap
(plantilla de función)

std::unexpected:: unexpected

constexpr unexpected ( const unexpected & ) = default ;
(1)
constexpr unexpected ( unexpected && ) = default ;
(2)
template < class Err = E >
constexpr explicit unexpected ( Err && e ) ;
(3)
template < class ... Args >
constexpr explicit unexpected ( std:: in_place_t , Args && ... args ) ;
(4)
template < class U, class ... Args >

constexpr explicit unexpected ( std:: in_place_t ,

std:: initializer_list < U > il, Args && ... args ) ;
(5)

Construye un objeto std::unexpected .

1,2) Constructor de copia/movimiento. Copia o mueve el valor almacenado, respectivamente.
3) Construye el valor almacenado, como si se inicializara directamente un valor de tipo E desde std:: forward < Err > ( e ) .
4) Construye el valor almacenado, como si se inicializara directamente un valor de tipo E a partir de los argumentos std:: forward < Args > ( args ) ... .
5) Construye el valor almacenado, como si se inicializara directamente un valor de tipo E a partir de los argumentos il, std:: forward < Args > ( args ) ... .

Parámetros

e - valor con el cual inicializar el valor contenido
args... - argumentos con los cuales inicializar el valor contenido
il - lista de inicialización con la cual inicializar el valor contenido

Excepciones

Lanza cualquier excepción lanzada por el constructor de E .

std::unexpected:: error

constexpr const E & error ( ) const & noexcept ;

constexpr E & error ( ) & noexcept ;
constexpr const E && error ( ) const && noexcept ;

constexpr E && error ( ) && noexcept ;

Devuelve una referencia al valor almacenado.

std::unexpected:: swap

constexpr void swap ( unexpected & other ) noexcept ( std:: is_nothrow_swappable_v < E > ) ;

Intercambia los valores almacenados, como si fuera mediante using std:: swap ; swap ( error ( ) , other. error ( ) ) ; .

El programa está mal formado si std:: is_swappable_v < E > es falso.

operator== (std::unexpected)

template < class E2 >
friend constexpr bool operator == ( unexpected & x, std :: unexpected < E2 > & y ) ;

Compara los valores almacenados, como si fuera return x. error ( ) == y. error ( ) .

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

Esta función no es visible para la búsqueda no calificada ordinaria o la búsqueda calificada , y solo puede ser encontrada mediante búsqueda dependiente de argumentos cuando std::unexpected<E> es una clase asociada de los argumentos.

swap (std::unexpected)

friend constexpr void
swap ( unexpected & x, unexpected & y ) noexcept ( noexcept ( x. swap ( y ) ) ) ;

Equivalente a x. swap ( y ) .

Esta sobrecarga participa en la resolución de sobrecarga solo si std:: is_swappable_v < E > es verdadero.

Esta función no es visible para la búsqueda no calificada ordinaria o la búsqueda calificada , y solo puede ser encontrada mediante búsqueda dependiente de argumentos cuando std::unexpected<E> es una clase asociada de los argumentos.

Guías de deducción

template < class E >
unexpected ( E ) - > unexpected < E > ;
(desde C++23)

La guía de deducción se proporciona para unexpected para permitir la deducción a partir del argumento del constructor.

Notas

Antes de C++17, el nombre std::unexpected denotaba la función llamada por el runtime de C++ cuando se violaba una especificación de excepción dinámica.

Ejemplo

Ejecutar este código 
#include <expected>
#include <iostream>
enum class error
{
    compile_time_error,
    runtime_error
};
[[nodiscard]] auto unexpected_runtime_error() -> std::expected<int, error>
{
    return std::unexpected(error::runtime_error);
}
int main()
{
    std::expected<double, int> ex = std::unexpected(3);
    if (!ex)
        std::cout << "ex contiene un valor de error\n";
    if (ex == std::unexpected(3))
        std::cout << "El valor de error es igual a 3\n";
    const auto e = unexpected_runtime_error();
    e.and_then([](const auto& e) -> std::expected<int, error>
    {
        std::cout << "and_then: " << int(e); // no se imprime
        return {};
    })
    .or_else([](const auto& e) -> std::expected<int, error>
    {
        std::cout << "or_else: " << int(e); // imprime esta línea
        return {};
    });
}

Salida: 

ex contiene un valor de error
El valor de error es igual a 3
or_else: 1

Véase también

construye el objeto expected
(función miembro pública)
devuelve el valor esperado
(función miembro pública)
intercambia los contenidos
(función miembro pública)
(C++23)
especializa el algoritmo std::swap
(función)
(C++23)
compara objetos expected
(plantilla de función)