Namespaces
Variants

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

    De es.cppreference.net
     
    C++
    Soporte del compilador
    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 la 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
     
    constexpr expected();
    		(1) (desde C++23) 
    constexpr expected( const expected& other );
    		(2) (desde C++23) 
    constexpr expected( expected&& other ) noexcept(/* see below */);
    		(3) (desde C++23) 
    template< class U, class G >
constexpr explicit(/* see below */) expected( const expected<U, G>& other );
    		(4) (desde C++23) 
    template< class U, class G >
constexpr explicit(/* see below */) 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)

    Construye un nuevo objeto expected.

    1) Constructor por defecto. Si T no es (posiblemente cv-cualificado) void, construye un objeto que contiene un valor esperado, el cual es inicializado por valor.
    Después de la construcción, has_value() devuelve true.
    Esta sobrecarga participa en la resolución de sobrecarga solo si T es (posiblemente cv-cualificado) 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 inesperado, el cual es inicializado directamente desde other.error(). En caso contrario, si T no es (posiblemente cv-cualificado) void, el nuevo objeto contiene un valor esperado, el cual es inicializado directamente desde *other.
    Después de la construcción, has_value() es igual a other.has_value().
    Este constructor está definido como eliminado a menos que
    • ya sea que T es (posiblemente cv-cualificado) 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 que T es (posiblemente cv-cualificado) void, o std::is_trivially_copy_constructible_v<T> es true, y
    • std::is_trivially_copy_constructible_v<E> es true.
    3) Constructor de movimiento. Si other.has_value() es false, el nuevo objeto contiene un valor inesperado, el cual es inicializado directamente desde std::move(other.error()). En caso contrario, si T no es (posiblemente cv-cualificado) void, el nuevo objeto contiene un valor esperado, el cual es inicializado directamente desde 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 solo si
    • ya sea que T es (posiblemente cv-cualificado) 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 sea std::add_lvalue_reference_t<const U> para (4) y U para (5), y
    • GF sea const G& para (4) y G para (5).
    Si other.has_value() es false, el nuevo objeto contiene un valor inesperado, el cual es inicializado directamente desde std::forward<GF>(other.error()). En caso contrario, si T no es (posiblemente cv-cualificado) void, el nuevo objeto contiene un valor esperado, el cual es inicializado directamente desde 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 las siguientes condiciones respectivamente:
    • Ya sea
      • T es (posiblemente cv-cualificado) 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 cv-cualificado) bool, T no es construible ni convertible desde ninguna 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 desde ninguna 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 inicializara directamente (pero no mediante lista de inicialización directa) 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 cv-cualificado) 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 cv-cualificado) bool, std::remove_cvref_t<U> no es una especialización de std::expected.
    7,8) Sea GF sea const G& para (7) y G para (8). Construye un objeto que contiene un valor inesperado, el cual es inicializado directamente desde std::forward<GF>(e.error()).
    Después de la construcción, has_value() devuelve false.
    Estas sobrecargas participan en la resolución de sobrecarga solo si std::is_constructible_v<E, GF> es true.
    9) Construye un objeto que contiene un valor esperado, el cual es inicializado directamente a partir de los argumentos std::forward<Args>(args)....
    Después de la construcción, has_value() devuelve true.
    Esta sobrecarga participa en la resolución de sobrecarga solo si std::is_constructible_v<T, Args...> es true.
    10) Construye un objeto que contiene un valor esperado, el cual es inicializado directamente a partir de los argumentos il, std::forward<Args>(args)....
    Después de la construcción, has_value() devuelve true.
    Esta sobrecarga participa en la resolución de sobrecarga solo si std::is_constructible_v<T, std::initializer_list<U>&, Args...> es true.
    11) Construye un objeto tal que después de la construcción, has_value() devuelve true.
    12) Construye un objeto que contiene un valor inesperado, el cual es inicializado directamente a partir de los argumentos std::forward<Args>(args)....
    Después de la construcción, has_value() devuelve false.
    Esta sobrecarga participa en la resolución de sobrecarga solo si std::is_constructible_v<E, Args...> es true.
    13) Construye un objeto que contiene un valor inesperado, el cual es inicializado directamente a partir de los argumentos il, std::forward<Args>(args)....
    Después de la construcción, has_value() devuelve false.
    Esta sobrecarga participa en la resolución de sobrecarga solo si std::is_constructible_v<E, std::initializer_list<U>&, Args...> es true.

    Parámetros

    other - otro objeto expected cuyo valor contenido es copiado
    e - std::unexpected objeto cuyo valor contenido es copiado
    v - 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

    Ejemplo

    Esta sección está incompleta
    Motivo: sin ejemplo

    Informes de defectos

    Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

    DR Aplicado a Comportamiento publicado Comportamiento correcto
    LWG 3886 C++23 el argumento de plantilla por defecto de overload ( 6 ) era T cambiado a std:: remove_cv_t < T >

    Véase también

    (C++23)
    		representado como un valor inesperado
    (plantilla de clase)
    (C++17)
    		etiqueta de construcción in situ
    (etiqueta)
    (C++23)
    		etiqueta de construcción in situ para valor inesperado en expected
    (etiqueta)