std::optional<T>::operator=

optional& operator=( std::nullopt_t ) noexcept;	(1)	(since C++17)
constexpr optional& operator=( const optional& other );	(2)	(since C++17)
constexpr optional& operator=( optional&& other ) noexcept(/* see below */);	(3)	(since C++17)
template< class U = T > optional& operator=( U&& value );	(4)	(since C++17)
template< class U > optional& operator=( const optional<U>& other );	(5)	(since C++17)
template< class U > optional& operator=( optional<U>&& other );	(6)	(since C++17)

Replaces contents of *this with the contents of other

1) If *this contains a value before the call, the contained value is destroyed by calling its destructor as if by value().T::~T(). *this does not contain a value after this call.

2-3) Assigns the state of other.

If both *this and other do not contain a value, the function has no effect.
If *this contains a value, but other does not, then the contained value is destroyed by calling its destructor. *this does not contain a value after the call.
If other contains a value, then depending on whether *this contains a value, the contained value is either direct-initialized or assigned from *other (2) or std::move(*other) (3). Note that a moved-from optional still contains a value.
Overload (2) is defined as deleted unless std::is_copy_constructible_v<T> and std::is_copy_assignable_v<T> are both true. It is trivial if std::is_trivially_copy_constructible_v<T>, std::is_trivially_copy_assignable_v<T> and std::is_trivially_destructible_v<T> are all true.
Overload (3) does not participate in overload resolution unless std::is_move_constructible_v<T> and std::is_move_assignable_v<T> are both true. It is trivial if std::is_trivially_move_constructible_v<T>, std::is_trivially_move_assignable_v<T> and std::is_trivially_destructible_v<T> are all true.

4) Perfect-forwarded assignment: depending on whether *this contains a value before the call, the contained value is either direct-initialized from std::forward(value) or assigned from std::forward(value). The function does not participate in overload resolution unless std::decay_t (until C++20)std::remove_cvref_t (since C++20) is not std::optional<T>, std::is_constructible_v<T, U> is true, std::is_assignable_v<T&, U> is true, and at least one of the following is true:

T is not a scalar type;
std::decay_t is not T.

5-6) Assigns the state of other.

If both *this and other do not contain a value, the function has no effect.
If *this contains a value, but other does not, then the contained value is destroyed by calling its destructor. *this does not contain a value after the call.
If other contains a value, then depending on whether *this contains a value, the contained value is either direct-initialized or assigned from *other (5) or std::move(*other) (6). Note that a moved-from optional still contains a value.
These overloads do not participate in overload resolution unless the following conditions are met:
- T is not constructible, convertible, or assignable from any expression of type (possibly const) std::optional, i.e., the following 12 type traits are all false:
 - std::is_constructible_v<T, std::optional&>
 - std::is_constructible_v<T, const std::optional&>
 - std::is_constructible_v<T, std::optional&&>
 - std::is_constructible_v<T, const std::optional&&>
 - std::is_convertible_v<std::optional&, T>
 - std::is_convertible_v<const std::optional&, T>
 - std::is_convertible_v<std::optional&&, T>
 - std::is_convertible_v<const std::optional&&, T>
 - std::is_assignable_v<T&, std::optional&>
 - std::is_assignable_v<T&, const std::optional&>
 - std::is_assignable_v<T&, std::optional&&>
 - std::is_assignable_v<T&, const std::optional&&>.
- For overload (5), std::is_constructible_v<T, const U&> and std::is_assignable_v<T&, const U&> are both true.
- For overload (6), std::is_constructible_v<T, U> and std::is_assignable_v<T&, U> are both true.

Parameters

other	-	another `optional` object whose contained value to assign
value	-	value to assign to the contained value

Return value

*this

Exceptions

2-6) Throws any exception thrown by the constructor or assignment operator of T. If an exception is thrown, the initialization state of *this (and of other in case of (2-3) and (5-6) ) is unchanged, i.e. if the object contained a value, it still contains a value, and the other way round. The contents of value and the contained values of *this and other depend on the exception safety guarantees of the operation from which the exception originates (copy-constructor, move-assignment, etc.).
(3) has the following

noexcept specification:

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

Notes

An optional object op may be turned into an empty optional with both op = {}; and op = nullopt;. The first expression constructs an empty optional object with {} and assigns it to op.

Example

Run this code

#include <optional>
#include <iostream>
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';
}

Output:

abc def

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR	Applied to	Behavior as published	Correct behavior
P0602R4	C++17	copy/move assignment operator may not be trivial even if underlying operations are trivial	required to propagate triviality

Language
Standard Library Headers
Freestanding and hosted implementations
Named requirements
Language support library
Concepts library (C++20)
Diagnostics library
Utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Input/output library
Localizations library
Regular expressions library (C++11)
Atomic operations library (C++11)
Thread support library (C++11)
Filesystem library (C++17)
Technical Specifications

Member functions
optional::optional
optional::~optional
optional::operator=
Observers
optional::operator->optional::operator*
optional::operator booloptional::has_value
optional::value
optional::value_or
Modifiers
optional::emplace
optional::swap
optional::reset
Non-member functions
operator==operator!=operator<operator<=operator>operator>=
make_optional
swap
Deduction guides
Helper classes
hash
nullopt_t
in_place_t
bad_optional_access
Helper objects
nullopt
in_place