std::optional<T>::operator=

 

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::optional

Funciones miembro

optional::optional

optional::~optional

optional::operator=

Observadores

optional::operator->optional::operator*

optional::operator booloptional::has_value

optional::value

optional::value_or

Modificadores

optional::emplace

optional::swap

optional::reset

Funciones no miembro

operator==operator!=operator<operator<=operator>operator>=operator<=> (C++20)

make_optional

swap

Guías de deducción

Clases auxiliares

hash

nullopt_t

in_place_t

bad_optional_access

Objetos auxiliares

nullopt

in_place

 

<tbody> </tbody>

optional& operator=( std::nullopt_t ) noexcept;	(1)	(desde C++17)
constexpr optional& operator=( const optional& other );	(2)	(desde C++17)
constexpr optional& operator=( optional&& other ) noexcept(/* véase más abajo */);	(3)	(desde C++17)
template< class U = T > optional& operator=( U&& value );	(4)	(desde C++17)
template< class U > optional& operator=( const optional<U>& other );	(5)	(desde C++17)
template< class U > optional& operator=( optional<U>&& other );	(6)	(desde C++17)

See More

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

1) Si *this contiene un valor antes de la llamada, el valor contenido se destruye llamando a su destructor como si lo fuera por value().T::~T(). *this no contiene un valor después de esta llamada.

2-3) Asigna el estado de other.

• Si tanto *this como other no contienen un valor, la función no tiene efecto.
• Si *this contiene un valor, pero other no, entonces el valor contenido se destruye llamando a su destructor. *this no contiene un valor después de esta llamada.
• Si other contiene un valor, entonces dependiendo si *this contiene un valor, el valor contenido es o bien inicializado directamente o asignado de *other (2) o std::move(*other) (3). Observa que un optional cuyo valor ha sido movido aún contiene un valor.
• La sobrecarga (2) se define como eliminada a menos que std::is_copy_constructible_v<T> y std::is_copy_assignable_v<T> sean ambas true. Es trivial si std::is_trivially_copy_constructible_v<T>, std::is_trivially_copy_assignable_v<T> y std::is_trivially_destructible_v<T> son todas true.
• La sobrecarga (3) no participa en la resolución de sobrecargas a menos que std::is_move_constructible_v<T> y std::is_move_assignable_v<T> sean ambas true. Es trivial si std::is_trivially_move_constructible_v<T>, std::is_trivially_move_assignable_v<T> y std::is_trivially_destructible_v<T> son todas true.

4) Asignación de reenvío perfecto: Dependiendo si *this contiene un valor antes de la llamada, el valor contenido es o bien inicializado directamente de std::forward<U>(value) o asignado de std::forward<U>(value). La función no participa en la resolución de sobrecargas a menos que std::decay_t<U> (hasta C++20)std::remove_cvref_t<U> (desde C++20) no sea std::optional<T>, std::is_constructible_v<T, U> sea true, std::is_assignable_v<T&, U> sea true, y al menos uno de los siguientes sea verdadero:

• T no es un tipo escalar;
• std::decay_t<U> no es T.

5-6) Asigna el estado de other.

• Si tanto *this como other no contienen un valor, la función no tiene efecto.
• Si *this contiene un valor, pero other no, entonces el valor contenido se destruye llamando a su destructor. *this no contiene un valor después de esta llamada.
• Si other contiene un valor, entonces dependiendo si *this contiene un valor, el valor contenido es o bien inicializado directamente o asignado de *other (5) o std::move(*other) (6). Observa que un optional cuyo valor ha sido movido aún contiene un valor.
• Estas sobrecargas no participan en la resolución de sobrecargas a menos que se cumplan las siguientes condiciones:
  • T no es construible, convertible, o asignable de cualquier expresión de tipo (posiblemente const) std::optional<U>, es decir, los siguientes 12 rasgos de tipo son todos false:
    • std::is_constructible_v<T, std::optional<U>&>
    • std::is_constructible_v<T, const std::optional<U>&>
    • std::is_constructible_v<T, std::optional<U>&&>
    • std::is_constructible_v<T, const std::optional<U>&&>
    • std::is_convertible_v<std::optional<U>&, T>
    • std::is_convertible_v<const std::optional<U>&, T>
    • std::is_convertible_v<std::optional<U>&&, T>
    • std::is_convertible_v<const std::optional<U>&&, T>
    • std::is_assignable_v<T&, std::optional<U>&>
    • std::is_assignable_v<T&, const std::optional<U>&>
    • std::is_assignable_v<T&, std::optional<U>&&>
    • std::is_assignable_v<T&, const std::optional<U>&&>.
  • Para la sobrecarga (5), std::is_constructible_v<T, const U&> y std::is_assignable_v<T&, const U&> son ambas true.
  • Para la sobrecarga (6), std::is_constructible_v<T, U> y std::is_assignable_v<T&, U> son ambas true.

Parámetros

other	-	Otro objeto optional cuyo valor contenido hay que asignar.
value	-	Valor a asignar al valor contenido.

Valor de retorno

*this

Excepciones

2-6) Lanza cualquier excepción lanzada por el constructor o el operador de asignación de T. Si se lanza una excepción, el estado de inicialización de *this (y de other en caso de (2-3) y (5-6) ) no ha cambiado, es decir, si el objeto contenía un valor, todavía contiene un valor, y viceversa. El contenido de value y los valores contenidos de *this y de other dependen de las garantías de seguridad de excepciones de la operación de la que se origina la excepción (constructor de copia, asignación de movimiento, etc.).
(3) tiene la siguiente

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

<tbody> </tbody>

noexcept(std::is_nothrow_move_assignable<T>::value && std::is_nothrow_move_constructible<T>::value)

Notas

Un objeto optional 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.

Ejemplo

Ejecuta este código

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

Salida:

abc def

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
P0602R4	C++17	Los constructores de copia/movimiento pueden no ser triviales incluso si el constructor subyacente es trivial.	Se requirió que propagase la trivialidad.

Véase también

See also

emplace

Construye el valor contenido en el sitio. (función miembro pública)