Namespaces
Variants

std::optional<T>:: operator=

From cppreference.net
C++
Utilities library
std::optional
optional & operator = ( std:: nullopt_t ) noexcept ;
(1) (desde C++17)
(constexpr desde C++20)
constexpr optional & operator = ( const optional & other ) ;
(2) (desde C++17)
constexpr optional & operator =
( optional && other ) noexcept ( /* ver más abajo */ ) ;
(3) (desde C++17)
template < class U >
optional & operator = ( const optional < U > & other ) ;
(4) (desde C++17)
(constexpr desde C++20)
template < class U >
optional & operator = ( optional < U > && other ) ;
(5) (desde C++17)
(constexpr desde C++20)
template < class U = std:: remove_cv_t < T > >
optional & operator = ( U && value ) ;
(6) (desde C++17)
(constexpr desde C++20)

Reemplaza el contenido de * this con el contenido de other .

1) Si * this contiene un valor, llama a val  - > T :: ~T ( ) para destruir el valor contenido; de lo contrario no tiene efecto. * this no contiene un valor después de esta llamada.
2-5) Asigna el estado de other . has_value() devuelve other. has_value ( ) después de esta llamada.
Efecto * this contiene un valor * this no contiene un valor
other contiene un valor
  • para las sobrecargas (2,4) , asigna * other al valor contenido
  • para las sobrecargas (3,5) , asigna std :: move ( * other ) al valor contenido
  • para las sobrecargas (2,4) , inicializa-directamente-no-lista el valor contenido con * other
  • para las sobrecargas (3,5) , inicializa-directamente-no-lista el valor contenido con std :: move ( * other )
other no contiene un valor destruye el valor contenido llamando val  - > T :: ~T ( ) sin efecto
2) Si std:: is_copy_constructible_v < T > o std:: is_copy_assignable_v < T > es false , el operador de asignación se define como eliminado.
Si std:: is_trivially_copy_constructible_v < T > , std:: is_trivially_copy_assignable_v < T > y std:: is_trivially_destructible_v < T > son todos true , el operador de asignación es trivial.
3) Esta sobrecarga participa en la resolución de sobrecarga solo si std:: is_move_constructible_v < T > y std:: is_move_assignable_v < T > son ambos true .
Si std:: is_trivially_move_constructible_v < T > , std:: is_trivially_move_assignable_v < T > y std:: is_trivially_destructible_v < T > son todos true , el operador de asignación es trivial.
4,5) These overloads participate in overload resolution only if all following conditions are satisfied:
6) Si * this contiene un valor, asigna std:: forward < U > ( value ) al valor contenido; de lo contrario inicializa directamente-no-por-lista el valor contenido con std:: forward < U > ( value ) . * this contiene un valor después de esta llamada.
Esta sobrecarga participa en la resolución de sobrecarga solo si se cumplen todas las siguientes condiciones:
  1. ↑ En otras palabras, T no es construible, convertible, ni asignable desde ninguna expresión de tipo (posiblemente calificado como const) std:: optional < U >

Contenidos

Parámetros

otro - otro objeto optional cuyo valor contenido asignar
valor - valor a asignar al valor contenido

Valor de retorno

* this

Excepciones

2-6) Lanza cualquier excepción lanzada por el constructor u operador de asignación de T . Si se lanza una excepción, el estado de inicialización de * this (y de other en el caso de ( 2-5 ) ) permanece sin cambios, es decir, si el objeto contenía un valor, sigue conteniendo un valor, y viceversa. El contenido de value y los valores contenidos de * this y other dependen de las garantías de seguridad ante excepciones de la operación desde la que se origina la excepción (constructor de copia, asignación de movimiento, etc.).
3) Tiene la siguiente
noexcept especificación:
noexcept ( std:: is_nothrow_move_assignable_v < T > &&
std:: is_nothrow_move_constructible_v < T > )

Notas

Un objeto opcional op puede convertirse en un optional vacío tanto con op = { } ; como con op = nullopt ; . La primera expresión construye un objeto optional vacío con { } y lo asigna a op .

Macro de prueba de características Valor Std Característica
__cpp_lib_optional 202106L (C++20)
(DR20) 		Completamente constexpr ( 1 ) , ( 4-6 )

Ejemplo

Ejecutar este código 
#include <iostream>
#include <optional>
int main()
{
    std::optional<const char*> s1 = "abc", s2; // constructor
    s2 = s1; // assignment
    s1 = "def"; // decaying assignment (U = char[4], T = const char*)
    std::cout << *s2 << ' ' << *s1 << '\n';
}

Salida: 

abc def

Informes de defectos

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

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 3886 C++17 el argumento de plantilla predeterminado de la sobrecarga ( 6 ) era T cambiado a std:: remove_cv_t < T >
P0602R4 C++17 el operador de asignación de copia/traslado podría no ser trivial
incluso si las operaciones subyacentes son triviales 		requerido propagar trivialidad
P2231R1 C++20 las sobrecargas ( 1,4-6 ) no eran constexpr convertidas en constexpr

Véase también

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