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

`constexpr expected& operator=( const expected& other );`	(1)	(desde C++23)
`constexpr expected& operator=( expected&& other ) noexcept(/véase abajo/);`	(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 calificado con cv) void y other.has_value() es true.
De lo contrario, destruye el valor contenido actualmente (no hace nada si this->has_value() es true y T es (posiblemente calificado con cv) void), y hace que *this contenga una copia del valor contenido en other.

Si other.has_value() es true y T es (posiblemente calificado con cv) void, no construye el nuevo valor. En caso contrario, el nuevo valor se construye por copia (1) o se construye por movimiento (2) a partir de *other o other.error(), según corresponda. Si se lanza una excepción, se conserva el valor anterior; *this no queda sin valor.

Si no se lanzó ninguna excepción tras la asignación, has_value() es igual a other.has_value().

La sobrecarga (1) se define como eliminada, a menos que
- o T es (posiblemente calificado con cv) void o std::is_copy_assignable_v<T> es true, y
- o T es (posiblemente calificado con cv) 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 uno de los siguientes es true:
  - T es (posiblemente calificado con cv) void
  - std::is_nothrow_move_constructible_v<T>
  - std::is_nothrow_move_constructible_v<E>
La sobrecarga (2) participa en la resolución de sobrecargas solo si
- o T es (posiblemente calificado con cv) void o std::is_move_assignable_v<T> es true, y
- o T es (posiblemente calificado con cv) 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 uno de los siguientes es true:
  - T es (posiblemente calificado con cv) void
  - std::is_nothrow_move_constructible_v<T>
  - std::is_nothrow_move_constructible_v<E>

3) Asigna a partir del valor esperado.

Si this->has_value() es true, es equivalente a **this = std::forward<U>(v).
De lo contrario, destruye el valor contenido en *this, y hace que *this contenga un valor inicializado a partir de std::forward<U>(v). Si se lanza una excepción, se conserva el valor anterior; *this no se vuelve sin valor.

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

Esta sobrecarga solo participa en la resolución de sobrecargas 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 uno de los siguientes 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 a partir del valor no esperado..

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 calificado con cv) void), y hace que *this contenga un valor inicializado a partir de std::forward<GF>(e.error()). Si se lanza una excepción, se conserva el valor anterior; *this no pierde su valor.
De lo contrario, es equivalente a this->error() = std::forward<GF>(e.error()).

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

Esta sobrecarga solo participa en la resolución de sobrecargas si
- std::is_constructible_v<E, GF> es true, y
- std::is_assignable_v<E&, GF> es true, y
- al menos uno de los siguientes es true:
  - T es (posiblemente calificado con cv) 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 void (posiblemente calificado con cv), la destrucción del valor antiguo y la construcción del valor nuevo se realizan como si fuera mediante la siguiente función reinit_expected (exclusiva para fines de exposición).

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)...); // puede lanzar
        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)...); // puede lanzar
        }
        catch (...)
        {
            std::construct_at(std::addressof(old_val), std::move(temp));
            throw;
        }
    }
}

Parámetros

other	-	Otro objeto `expected` cuyo valor contenido se asignará.
value	-	Valor que se asignará al valor contenido.
e	-	Objeto `std::unexpected` cuyo valor contenido se asignará.

Valor de retorno

*this

Excepciones

1) Lanza cualquier excepción lanzada por el constructor de copia o el operador de asignación de copia de T o E.

2) Si T es (posiblemente calificado con cv) void,

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

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

De lo contrario,

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

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>)

3) Lanza cualquier excepción lanzada por el constructor o el operador de asignación de T.

4,5) Lanza cualquier excepción lanzada por el constructor o el operador de asignación 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 (3) era `T`.	Se cambió a `std::remove_cv_t<T>`.
LWG 4025	C++23	La asignación por movimiento (2) de `std::expected<void, E>` estaba definida como eliminada si `E` no es construible por movimiento ni asignable por movimiento.	No participa en la resolución de sobrecargas en este caso.

Véase también

emplace

Construye el valor esperado in situ.
(función miembro pública) [editar]

cppreference.com

Buscar

Espacios de nombres

Variantes

Vistas

Acciones