Ver el código de «cpp/utility/expected/unexpected»

No tienes permiso para modificar esta página, por el siguiente motivo:
La acción que has solicitado está restringida a los usuarios de uno de estos 2 grupos: Usuarios, Administradores.
Puedes ver y copiar el código fuente de esta página.
{{cpp/title|unexpected}}
{{cpp/utility/expected/navbar}}

{{dcl begin}}
{{dcl header|expected}}
{{dcl|since=c++23|1=
template< class E >
class unexpected;
}}
{{dcl end}}

La plantilla de clase {{tt|std::unexpected}} representa un valor no esperado almacenado en {{lc|std::expected}}. En particular, {{lc|std::expected}} tiene constructores con {{tt|std::unexpected}} como argumento único, lo que crea un objeto {{rlpt|/|expected}} que contiene un valor no esperado.

Un programa está mal formado si ejempla un {{tt|unexpected}} con un tipo que no es de objeto, un tipo ''array'', una especialización de {{tt|std::unexpected}} o un tipo calificado por {{c/core|const volatile}}.

===Parámetros de plantilla===
{{par begin}}
{{par|E|el tipo del valor no esperado. El tipo no debe ser un tipo ''array'', un tipo que no sea de objeto, una especialización de {{tt|std::unexpected}} o un tipo calificado por {{c/core|const volatile}}.}}
{{par end}}

===Funciones miembro===
{{dsc begin}}
{{dsc mem ctor|{{PAGENAME}}#ctor|Construye el objeto {{tt|unexpected}}.}}
{{dsc mem dtor|nolink=true|Destruye el objeto {{tt|unexpected}}, junto con el valor almacenado.|notes={{mark implicit}}}}
{{dsc mem fun|nolink=true|operator{{=}}|Asigna el valor almacenado|notes={{mark implicit}}}}
{{dsc mem fun|{{PAGENAME}}#error|title=error|Accede al valor almacenado.}}
{{dsc mem fun|{{PAGENAME}}#swap|title=swap|Intercambia el valor almacenado.}}
{{dsc end}}

===Funciones miembro===
{{dsc begin}}
{{dsc tfun|{{PAGENAME}}#compare|title=operator==|compares el valor almacenado|notes={{mark c++23}}}}
{{dsc tfun|{{PAGENAME}}#swap2|title=swap{{dsc small|(std::unexpected)}}|specializes the {{lc|std::swap}} algorithm|notes={{mark c++23}}}}
{{dsc end}}

{{anchor|ctor}}
{{member|1={{small|std::unexpected::}}unexpected|2=
{{dcl begin}}
{{dcl|num=1|1=
constexpr unexpected( const unexpected& ) = default;
}}
{{dcl|num=2|1=
constexpr unexpected( unexpected&& ) = default;
}}
{{dcl|num=3|1=
template< class Err = E >
constexpr explicit unexpected( Err&& e );
}}
{{dcl|num=4|1=
template< class... Args >
constexpr explicit unexpected( std::in_place_t, Args&&... args );
}}
{{dcl|num=5|1=
template< class U, class... Args >
constexpr explicit unexpected( std::in_place_t,
                               std::initializer_list<U> il, Args&&... args );
}}
{{dcl end}}

Construye un objeto {{tt|std::unexpected}}.

@1,2@ Constructor de copia/movimiento. Copia o mueve el valor almacenado, respectivamente.
@3@ Construye el valor almacenado, como si fuera por [[cpp/language/direct initialization|initialización directa]] de un valor de tipo {{tt|E}} de {{c|std::forward<Err>(e)}}.
* {{cpp/enable_if|
** {{c|std::is_same_v<std::remove_cvref_t<Err>, unexpected>}} es {{c/core|false}}, y
** {{c|std::is_same_v<std::remove_cvref_t<Err>, std::in_place_t>}} es {{c/core|false}}, y
** {{c|std::is_constructible_v<E, Err>}} es {{c/core|true}}.
}}
@4@ Construye el valor almacenado, como si fuera por [[cpp/language/direct initialization|initialización directa]] de un valor de tipo {{tt|E}} de los argumentos {{c|std::forward<Args>(args)...}}.
* {{cpp/enable_if|{{c|std::is_constructible_v<E, Args...>}} es {{c/core|true}}.}}
@5@ Construye el valor almacenado, como si fuera por [[cpp/language/direct initialization|initialización directa]] de un valor de tipo {{tt|E}} de los argumentos {{c|il, std::forward<Args>(args)...}}.
* {{cpp/enable_if|{{c|std::is_constructible_v<E, std::initializer_list<U>&, Args...>}} es {{c/core|true}}.}}

===Parámetros===
{{par begin}}
{{par|e|Valor con el que inicializar el valor contenido.}}
{{par|args...|Argumentos con los que inicializar el valor contenido.}}
{{par|il|Lista de inicializadores con la que inicializar el valor contenido.}}
{{par end}}

===Excepciones===
Lanza cualquier excepción lanzada por el constructor de {{tt|E}}.
}}

{{anchor|error}}
{{member|1={{small|std::unexpected::}}error|2=
{{dcl begin}}
{{dcl|1=
constexpr const E& error() const& noexcept;
constexpr E& error() & noexcept;
constexpr const E&& error() const&& noexcept;
constexpr E&& error() && noexcept;
}}
{{dcl end}}

Devuelve una referencia al valor almacenado.
}}

{{anchor|swap}}
{{member|1={{small|std::unexpected::}}swap|2=
{{dcl begin}}
{{dcl|1=
constexpr void swap( unexpected& other ) noexcept(std::is_nothrow_swappable_v<E>);
}}
{{dcl end}}

Intercambia los valores almacenados, como si fuera {{c|using std::swap; swap(error(), other.error());}}.

El programa está mal formado si {{c|std::is_swappable_v<E>}} es {{c/core|false}}.
}}

{{anchor|compare}}
{{member|1=operator=={{small|(std::unexpected)}}|2=
{{dcl begin}}
{{dcl|1=
template< class E2 >
friend constexpr bool operator==( unexpected& x, std::unexpected<E2>& y );
}}
{{dcl end}}

Compara los valores almacenados, como si fuera {{c|1=return x.error() == y.error()}}.

Si la expresión {{c|1=x.error() == e.error()}} no está bien formada, o si su resultado no se puede convertir a {{c/core|bool}}, el programa está mal formado.

{{cpp/hidden friend|std::unexpected<E>}}
}}

{{anchor|swap2}}
{{member|1=swap{{small|(std::unexpected)}}|2=
{{dcl begin}}
{{dcl|1=
friend constexpr void
swap( unexpected& x, unexpected& y ) noexcept(noexcept(x.swap(y)));
}}
{{dcl end}}

Equivalente a {{c|x.swap(y)}}.

{{cpp/enable if|{{c|std::is_swappable_v<E>}} es {{c/core|true}}.}}

{{cpp/hidden friend|std::unexpected<E>}}
}}

===Guías de deducción===
{{dcl begin}}
{{dcl|since=c++23|1=
template< class E >
unexpected(E) -> unexpected<E>;
}}
{{dcl end}}

La [[cpp/language/class template argument deduction|guía de deducción]] se proporciona para {{lc|unexpected}} para permitir la deducción del argumento del constructor.

===Notas===
Antes de C++17, el nombre {{ltt|cpp/error/unexpected|std::unexpected}} denotaba la función llamada por el entorno de ejecución de C++ cuando se violaba una especificación de excepción dinámica..

===Ejemplo===
{{example
|code=
#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 del 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 {};
    });
}
|output=
ex contiene un valor de error
El valor del error es igual a 3
or_else: 1
}}

===Véase también===
{{dsc begin}}
{{dsc inc|cpp/utility/expected/dsc constructor}}
{{dsc inc|cpp/utility/expected/dsc operator cmp}}
{{dsc end}}

{{langlinks|de|en|fr|it|ja|pt|ru|zh}}
Plantillas usadas en esta página:
cppreference.com

Buscar

Espacios de nombres

Variantes

Vistas

Acciones

Ver el código de «cpp/utility/expected/unexpected»
