Namespaces
Variants

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

    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& operator=( const expected& other );
    		(1) (desde C++23) 
    constexpr expected& operator=( expected&& other ) noexcept(/*see below*/);
    		(2) (desde C++23) 
    template< class U = std::remove_cv_t<T> >
constexpr expected& operator=( U&& v );
    		(3) (desde C++23)
    (T no es cv void)    		 
    template< class G >
constexpr expected& operator=( const unexpected<G>& other );
    		(4) (desde C++23) 
    template< class G >
constexpr expected& operator=( unexpected<G>&& other );
    		(5) (desde C++23)

    Asigna un nuevo valor a un objeto expected existente.

    1,2) Asigna el estado de other.
    • Si this->has_value() es igual a other.has_value(), asigna el valor contenido en other. No hace nada si T es (posiblemente cv-cualificado) void y other.has_value() es true.
    • En caso contrario, destruye el valor actualmente contenido (no hace nada si this->has_value() es true y T es (posiblemente cv-cualificado) void), y hace que *this contenga una copia del valor contenido en other.
    Si other.has_value() es true y T es (posiblemente cv-cualificado) void, no construye el nuevo valor. En caso contrario, el nuevo valor se construye por copia (1) o por movimiento (2) desde *other o other.error(), según corresponda. Si se lanza una excepción, se retiene el valor antiguo; *this no se vuelve sin valor.

    Si no se lanzó ninguna excepción, después de la asignación, has_value() es igual a other.has_value().

    • La sobrecarga (1) se define como eliminada a menos que
      • ya sea T es (posiblemente cv-cualificado) void o std::is_copy_assignable_v<T> es true, y
      • ya sea T es (posiblemente cv-cualificado) void o std::is_copy_constructible_v<T> es true, y
      • std::is_copy_assignable_v<E> es true, y
      • std::is_copy_constructible_v<E> es true, y
      • al menos una de las siguientes condiciones es true:
        • T es (posiblemente cv-cualificado) void
        • std::is_nothrow_move_constructible_v<T>
        • std::is_nothrow_move_constructible_v<E>
    • La sobrecarga (2) participa en la resolución de sobrecarga solo si
      • ya sea T es (posiblemente cv-cualificado) void o std::is_move_assignable_v<T> es true, y
      • ya sea T es (posiblemente cv-cualificado) void o std::is_move_constructible_v<T> es true, y
      • std::is_move_assignable_v<E> es true, y
      • std::is_move_constructible_v<E> es true, y
      • al menos una de las siguientes condiciones es true:
        • T es (posiblemente cv-cualificado) void
        • std::is_nothrow_move_constructible_v<T>
        • std::is_nothrow_move_constructible_v<E>
    3) Asigna desde un valor esperado.
    • Si this->has_value() es true, equivalente a **this = std::forward<U>(v).
    • En caso contrario, destruye el valor contenido en *this, y hace que *this contenga un valor inicializado desde std::forward<U>(v). Si se lanza una excepción, se retiene el valor antiguo; *this no se vuelve sin valor.

    Si no se lanzó ninguna excepción, después de la asignación, this->has_value() es true.

    • Esta sobrecarga participa en la resolución de sobrecarga solo si
      • std::is_same_v<expected, std::remove_cvref_t<U>> es false, y
      • std::remove_cvref_t<U> no es una especialización de std::unexpected, y
      • std::is_constructible_v<T, U> es true, y
      • std::is_assignable_v<T&, U> es true, y
      • al menos una de las siguientes condiciones es true:
        • std::is_nothrow_constructible_v<T, U>
        • std::is_nothrow_move_constructible_v<T>
        • std::is_nothrow_move_constructible_v<E>
    4,5) Asigna desde un valor inesperado.

    Sea GF const G& para la sobrecarga (4), y G para la sobrecarga (5).

    • Si this->has_value() es true, destruye el valor contenido en *this (no hace nada si T es (posiblemente cv-cualificado) void), y hace que *this contenga un valor inicializado desde std::forward<GF>(e.error()). Si se lanza una excepción, se retiene el valor antiguo; *this no se vuelve sin valor.
    • En caso contrario, equivalente a this->error() = std::forward<GF>(e.error()).

    Si no se lanzó ninguna excepción, después de la asignación, this->has_value() es false.

    • Esta sobrecarga participa en la resolución de sobrecarga solo si
      • std::is_constructible_v<E, GF> es true, y
      • std::is_assignable_v<E&, GF> es true, y
      • al menos una de las siguientes condiciones es true:
        • T es (posiblemente cv-cualificado) void
        • std::is_nothrow_constructible_v<E, GF>
        • std::is_nothrow_move_constructible_v<T>
        • std::is_nothrow_move_constructible_v<E>


    En todos los casos, si T no es (posiblemente cv-cualificado) void, la destrucción del valor antiguo y la construcción del nuevo valor se realizan como si fuera mediante la siguiente función expositiva reinit_expected. 

    template<class NewType, class OldType, class... Args>
constexpr void reinit_expected(NewType& new_val, OldType& old_val, Args&&... args)
{
    if constexpr (std::is_nothrow_constructible_v<NewType, Args...>)
    {
        std::destroy_at(std::addressof(old_val));
        std::construct_at(std::addressof(new_val), std::forward<Args>(args)...);
    }
    else if constexpr (std::is_nothrow_move_constructible_v<NewType>)
    {
        NewType temp(std::forward<Args>(args)...); // may throw
        std::destroy_at(std::addressof(old_val));
        std::construct_at(std::addressof(new_val), std::move(temp));
    }
    else
    {
        OldType temp(std::move(old_val));
        std::destroy_at(std::addressof(old_val));
        try
        {
            std::construct_at(std::addressof(new_val), std::forward<Args>(args)...); // may throw
        }
        catch (...)
        {
            std::construct_at(std::addressof(old_val), std::move(temp));
            throw;
        }
    }
}

    Parámetros

    other - otro objeto expected cuyo valor contenido asignar
    v - valor a asignar al valor contenido
    e - std::unexpected objeto cuyo valor contenido asignar
    newval - el valor contenido a ser construido
    oldval - el valor contenido a ser destruido
    args - los argumentos usados como inicializadores de newval

    Valor de retorno

    1-9) * this

    Excepciones

    2)
    noexcept especificación:
    noexcept (

    std:: is_nothrow_move_constructible_v < T > && std:: is_nothrow_move_assignable_v < T > &&

    std:: is_nothrow_move_constructible_v < E > && std:: is_nothrow_move_assignable_v < E > )
    7)
    noexcept especificación:
    noexcept ( std:: is_nothrow_move_constructible_v < E > && std:: is_nothrow_move_assignable_v < E > )

    Ejemplo

    Esta sección está incompleta
    Razón: 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 la sobrecarga ( 3 ) era T cambiado a std:: remove_cv_t < T >
    LWG 4025 C++23 la sobrecarga ( 7 ) se definía como eliminada si E no es
    move constructible o no es move assignable     		no participa en la
    resolución de sobrecarga en este caso

    Véase también

    		construye el valor esperado in-situ
    (función miembro pública)