std::expected<T,E>::expected

 

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

 

constexpr expected();	(1)	(desde C++23)
constexpr expected( const expected& other );	(2)	(desde C++23)
constexpr expected( expected&& other ) noexcept(/* véase más abajo */);	(3)	(desde C++23)
template< class U, class G > constexpr explicit(/* véase más abajo */) expected( const expected<U, G>& other );	(4)	(desde C++23)
template< class U, class G > constexpr explicit(/* véase más abajo */) expected( expected<U, G>&& other );	(5)	(desde C++23)
template< class U = std::remove_cv_t<T> > constexpr explicit(!std::is_convertible_v<U, T>) expected( U&& v );	(6)	(desde C++23) (T no es cv void)
template< class G > constexpr explicit(!std::is_convertible_v<const G&, E>) expected( const std::unexpected<G>& e );	(7)	(desde C++23)
template< class G > constexpr explicit(!std::is_convertible_v<G, E>) expected( std::unexpected<G>&& e );	(8)	(desde C++23)
template< class... Args > constexpr explicit expected( std::in_place_t, Args&&... args );	(9)	(desde C++23) (T no es cv void)
template< class U, class... Args > constexpr explicit expected( std::in_place_t, std::initializer_list<U> il, Args&&... args );	(10)	(desde C++23) (T no es cv void)
constexpr explicit expected( std::in_place_t ) noexcept;	(11)	(desde C++23) (T es cv void)
template< class... Args > constexpr explicit expected( std::unexpect_t, Args&&... args );	(12)	(desde C++23)
template< class U, class... Args > constexpr explicit expected( std::unexpect_t, std::initializer_list<U> il, Args&&... args );	(13)	(desde C++23)

See More

Construye un nuevo objeto expected.

1) Constructor por defecto. Si T no es (posiblemente calificada-cv void, construye un objeto que contiene un valor esperado, que es valor-inicializado.

Después de la construcción, has_value() devuelve true.

Esta sobrecarga solo participa en la resolución de sobrecargas si T es (posiblemente calificada-cv) void o std::is_default_constructible_v<T> es true.

2) Constructor de copia. Si other.has_value() es false, el nuevo objeto contiene un valor no esperado, que es directamente-inicializado a partir de other.error(). De lo contrario, si T no es (posiblemente calificada-cv void, el nuevo objeto contiene un valor esperado, que es directamente-inicializado a partir de *other.

Después de la construcción, has_value() es igual a other.has_value().

Este constructor se define como eliminado a menos que

• ya sea T es (posiblemente calificada-cv) void, o std::is_copy_constructible_v<T> es true, y
• std::is_copy_constructible_v<E> es true.

Este constructor es trivial si

• ya sea T es (posiblemente calificada-cv) void, o std::is_trivially_copy_constructible_v<T> es true, y
• std::is_trivially_copy_constructible_v<E> es true.

3) Constructor por movimiento. Si other.has_value() es false, el nuevo objeto contiene un valor no esperado, que es directamente-inicializado a partir de std::move(other.error()). De lo contrario, si T no es (posiblemente calificada-cv void, el nuevo objeto contiene un valor esperado, que es directamente-inicializado a partir de std::move(*other).

Después de la construcción, has_value() es igual a other.has_value().

Este constructor participa en la resolución de sobrecarga sólo si

• ya sea T es (posiblemente calificada-cv) void, o std::is_move_constructible_v<T> es true, y
• std::is_move_constructible_v<E> es true.

Este constructor es trivial si

• std::is_trivially_move_constructible_v<T> es true, y
• std::is_trivially_move_constructible_v<E> es true.

4,5) Sea

• UF std::add_lvalue_reference_t<const U> para (4) y U para (5), y
• GF const G& para (4) y G para (5).

Si other.has_value() es false, el nuevo objeto contiene un valor no esperado, que es directamente-inicializado a partir de std::forward<GF>(other.error()). De lo contrario, si T no es (posiblemente calificada-cv void, el nuevo objeto contiene un valor esperado, que es directamente-inicializado a partir de std::forward<UF>(*other).

Después de la construcción, has_value() es igual a other.has_value().

Cada uno de estos constructores no participa en la resolución de sobrecarga a menos que se cumplan, respectivamente, las siguientes condiciones:

• Ya sea
  • T es (posiblemente calificada-cv) void, y std::is_void_v<U> es true, o
  • std::is_constructible_v<T, UF> es true.
• std::is_constructible_v<E, GF> es true.
• Si T no es (posiblemente calificada-cv bool, T no es construible o convertible a partir de cualquier expresión de tipo (posiblemente const) std::expected<U, G>, es decir, los siguientes 8 valores son todos false:
  • std::is_constructible_v<T, std::expected<U, G>&
  • std::is_constructible_v<T, std::expected<U, G>
  • std::is_constructible_v<T, const std::expected<U, G>&
  • std::is_constructible_v<T, const std::expected<U, G>
  • std::is_convertible_v<std::expected<U, G>&, T>
  • std::is_convertible_v<std::expected<U, G>, T>
  • std::is_convertible_v<const std::expected<U, G>&, T>
  • std::is_convertible_v<const std::expected<U, G>, T>
• std::unexpected<E> no es construible a partir de cualquier expresión de tipo (posiblemente const) std::expected<U, G>, es decir, los siguientes 4 valores son todos false:
  • std::is_constructible_v<std::unexpected<E>, std::expected<U, G>&
  • std::is_constructible_v<std::unexpected<E>, std::expected<U, G>
  • std::is_constructible_v<std::unexpected<E>, const std::expected<U, G>&
  • std::is_constructible_v<std::unexpected<E>, const std::expected<U, G>

Estos constructores son explicit si std::is_convertible_v<UF, T> o std::is_convertible_v<GF, E> es false.

6) Construye un objeto que contiene un valor esperado, inicializado como si directamente-inicializando (pero no directamente-inicializando-por-lista) un objeto de tipo T con la expresión std::forward<U>(v).

Después de la construcción, has_value() devuelve true.

Este constructor no participa en la resolución de sobrecarga a menos que se cumplan las siguientes condiciones.:

• T no es (posiblemente calificada-cv void.
• std::is_same_v<std::remove_cvref_t<U>, std::in_place_t> es false.
• std::is_same_v<expected, std::remove_cvref_t<U>> es false.
• std::is_constructible_v<T, U> es true.
• std::remove_cvref_t<U> no es una especialización de std::unexpected.
• Si T es (posiblemente calificada-cv) bool, std::remove_cvref_t<U> no es una especialización de std::expected.

7,8) Sea GF const G& para (7) y G para (8). Construye un objeto que contiene un valor no esperado, que es directamente-inicializado a partir de std::forward<GF>(e.error()).

Después de la construcción, has_value() devuelve false.

Estas sobrecargas solo participan en la resolución de sobrecargas si std::is_constructible_v<E, GF> es true.

9) Construye un objeto que contiene un valor esperado, que es directamente-inicializado a partir de los argumentos std::forward<Args>(args)....

Después de la construcción, has_value() devuelve true.

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

10) Construye un objeto que contiene un valor esperado, que es directamente-inicializado a partir de los argumentos il, std::forward<Args>(args)....

Después de la construcción, has_value() devuelve true.

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

11) Construye un objeto de tal manera que después de la construcción, has_value() devuelve true.

12) Construye un objeto que contiene un valor no esperado, que es directamente-inicializado a partir de los argumentos std::forward<Args>(args)....

Después de la construcción, has_value() devuelve false.

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

13) Construye un objeto que contiene un valor no esperado, que es directamente-inicializado a partir de los argumentos il, std::forward<Args>(args)....

Después de la construcción, has_value() devuelve false.

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

other	-	Otro objeto expected cuyo valor contenido se copia.
e	-	Objeto std::unexpected cuyo valor contenido se copia.
v	-	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

1) Lanza cualquier excepción lanzada por el constructor de T.

Si T es (posiblemente calificada-cv) void,

Especificación noexcept:  

noexcept

  (desde C++11)

2) Lanza cualquier excepción lanzada por el constructor de T o E.

3) Si T es (posiblemente calificada-cv) void,

Especificación noexcept:   (desde C++11)

noexcept(std::is_nothrow_move_constructible_v<E>)

De lo contrario,

Especificación noexcept:   (desde C++11)

noexcept(std::is_nothrow_move_constructible_v<T> && std::is_nothrow_move_constructible_v<E>)

4,5) Lanza cualquier excepción lanzada por el constructor de T o E.

6) Lanza cualquier excepción lanzada por el constructor de T.

7,8) Lanza cualquier excepción lanzada por el constructor de E.

9,10) Lanza cualquier excepción lanzada por el constructor de T.

12,13) Lanza cualquier excepción lanzada por el constructor de E.

Ejemplo

Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

ID	Aplicado a	Comportamiento según lo publicado	Comportamiento correcto
LWG 3886	C++23	El argumento de plantilla por defecto de la sobrecarga (6) era T.	Se cambió a std::remove_cv_t<T>.

Véase también

unexpected (C++23)	Representado como un valor no esperado. (plantilla de clase)
in_place in_place_type in_place_index in_place_t in_place_type_t in_place_index_t (C++17)	Etiqueta de construcción en el sitio (in situ). (plantilla de clase)
unexpectunexpect_t (C++23)	Etiqueta de construcción in situ para un valor no esperado en expected. (tag)