std::unexpected

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos(C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación(C++11)

Biblioteca de servicios 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 apoyo de concurrencia(C++11)

Biblioteca de apoyo de ejecución(C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de servicios

Apoyo del lenguaje Apoyo de tipos (tipos básicos, RTTI) Biblioteca de macros de prueba de característica(C++20) Servicios del programa Apoyo de corrutinas(C++20) Funciones variádicas is_constant_evaluated (C++20) is_within_lifetime (C++26) initializer_list (C++11) source_location (C++20) Comparación de tres vías three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Servicios generales Objetos función Manipulación de bits(C++20) bitset hash (C++11) Operadores relacionales(en desuso en C++20) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Funciones de comparación de enteros cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Intercambio y operaciones de tipos swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Tipos vocabulario comunes pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

std::expected

Funciones miembro

expected::expected

expected::~expected

expected::operator=

Observadores

expected::operator->expected::operator*

expected::operator boolexpected::has_value

expected::value

expected::error

expected::value_or

Operaciones monádicas

expected::and_then

expected::or_else

expected::transform

expected::transform_error

Modificadores

expected::emplace

expected::swap

Funciones no miembro

operator==

swap(std::expected)

Clases auxiliares

unexpected

bad_expected_access

unexpect_tunexpect

 

Definido en el archivo de encabezado <expected>
template<class E > class unexpected;		(desde C++23)

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

Un programa está mal formado si ejempla un unexpected con un tipo que no es de objeto, un tipo array, una especialización de std::unexpected o un tipo calificado por constvolatile.

Parámetros de plantilla

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 std::unexpected o un tipo calificado por constvolatile.

Funciones miembro

(constructor)	Construye el objeto unexpected. (función miembro pública)
(destructor) (implícitamente declarado)	Destruye el objeto unexpected, junto con el valor almacenado. (función miembro pública)
operator= (implícitamente declarado)	Asigna el valor almacenado (función miembro pública)
error	Accede al valor almacenado. (función miembro pública)
swap	Intercambia el valor almacenado. (función miembro pública)

Funciones miembro

operator== (C++23)	compares el valor almacenado (plantilla de función)
swap(std::unexpected) (C++23)	specializes the std::swap algorithm (plantilla de función)

std::unexpected::unexpected

constexpr unexpected(const unexpected&)=default;	(1)
constexpr unexpected( unexpected&&)=default;	(2)
template<class Err = E > constexprexplicit unexpected( Err&& e );	(3)
template<class... Args> constexprexplicit unexpected(std::in_place_t, Args&&... args);	(4)
template<class U, class... Args> constexprexplicit 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 fuera por initialización directa de un valor de tipo E de std::forward<Err>(e).

• Esta sobrecarga solo participa en la resolución de sobrecargas si
  • std::is_same_v<std::remove_cvref_t<Err>, unexpected> es false, y
  • std::is_same_v<std::remove_cvref_t<Err>, std::in_place_t> es false, y
  • std::is_constructible_v<E, Err> es true.

4) Construye el valor almacenado, como si fuera por initialización directa de un valor de tipo E de los argumentos std::forward<Args>(args)....

• Esta sobrecarga solo participa en la resolución de sobrecargas si std::is_constructible_v<E, Args...> es true.

5) Construye el valor almacenado, como si fuera por initialización directa de un valor de tipo E de los argumentos il, std::forward<Args>(args)....

• Esta sobrecarga solo participa en la resolución de sobrecargas si std::is_constructible_v<E, std::initializer_list<U>&, Args...> es true.

Parámetros

e	-	Valor con el que inicializar el valor contenido.
args...	-	Argumentos con los que inicializar el valor contenido.
il	-	Lista de inicializadores con la que inicializar el valor contenido.

Excepciones

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

std::unexpected::error

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

Devuelve una referencia al valor almacenado.

std::unexpected::swap

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

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

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

operator==(std::unexpected)

template<class E2 > friendconstexprbool 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 se puede convertir a bool, el programa está mal formado.

Esta función no es visible a una búsqueda no calificada o calificada, y puede encontrarse solamente mediante la búsqueda dependiente de argumento cuando std::unexpected<E> es una clase asociada de los argumentos.

swap(std::unexpected)

friendconstexprvoid swap( unexpected& x, unexpected& y )noexcept(noexcept(x.swap(y)));

Equivalente a x.swap(y).

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

Esta función no es visible a una búsqueda no calificada o calificada, y puede encontrarse solamente mediante la búsqueda dependiente de argumento 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 del argumento del constructor.

Notas

Antes de C++17, el nombre 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

Ejecuta este código

#include <expected>#include <iostream>   enumclass 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";   constauto e = unexpected_runtime_error();   e.and_then([](constauto& e)->std::expected<int, error>{std::cout<<"and_then: "<<int(e);// no se imprimereturn{};}) .or_else([](constauto& e)->std::expected<int, error>{std::cout<<"or_else: "<<int(e);// imprime esta líneareturn{};});}

Salida:

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

Véase también

(constructor)	Construye el objeto expected. (función miembro pública)
operator== (C++23)	Compara objetos de tipo expected. (plantilla de función)