22 General utilities library [utilities]

22.5 Optional objects [optional]

22.5.3 Class template optional [optional.optional]

22.5.3.4 Assignment [optional.assign]

constexpr optional<T>& operator=(nullopt_t) noexcept;

Effects: If *this contains a value, calls val.T::~T() to destroy the contained value; otherwise no effect.

Postconditions: *this does not contain a value.

Returns: *this.

🔗

constexpr optional<T>& operator=(const optional& rhs);

Effects: See Table 67 .

Table 67 — optional::operator=(const optional&) effects [tab:optional.assign.copy]

🔗	*this contains a value	*this does not contain a value
🔗 rhs contains a value	assigns rhs.val to val	direct-non-list-initializes val with rhs.val
🔗 rhs does not contain a value	destroys the contained value by calling val.T::~T()	no effect

Postconditions: rhs.has_value() == this->has_value().

Returns: *this.

Remarks: If any exception is thrown, the result of the expression this->has_value() remains unchanged.

If an exception is thrown during the call to T's copy constructor, no effect.

If an exception is thrown during the call to T's copy assignment, the state of its contained value is as defined by the exception safety guarantee of T's copy assignment.

This operator is defined as deleted unless is_copy_constructible_v<T> is true and is_copy_assignable_v<T> is true.

If is_trivially_copy_constructible_v<T> && is_trivially_copy_assignable_v<T> && is_trivially_destructible_v<T> is true, this assignment operator is trivial.

🔗

constexpr optional& operator=(optional&& rhs) noexcept(see below);

Constraints: is_move_constructible_v<T> is true and is_move_assignable_v<T> is true.

Effects: See Table 68 .

The result of the expression rhs.has_value() remains unchanged.

Table 68 — optional::operator=(optional&&) effects [tab:optional.assign.move]

🔗	*this contains a value	*this does not contain a value
🔗 rhs contains a value	assigns std::move(rhs.val) to val	direct-non-list-initializes val with std::move(rhs.val)
🔗 rhs does not contain a value	destroys the contained value by calling val.T::~T()	no effect

Postconditions: rhs.has_value() == this->has_value().

Returns: *this.

Remarks: The exception specification is equivalent to: is_nothrow_move_assignable_v<T> && is_nothrow_move_constructible_v<T>

If any exception is thrown, the result of the expression this->has_value() remains unchanged.

If an exception is thrown during the call to T's move constructor, the state of rhs.val is determined by the exception safety guarantee of T's move constructor.

If an exception is thrown during the call to T's move assignment, the states of val and rhs.val are determined by the exception safety guarantee of T's move assignment.

If is_trivially_move_constructible_v<T> && is_trivially_move_assignable_v<T> && is_trivially_destructible_v<T> is true, this assignment operator is trivial.

🔗

template<class U = remove_cv_t<T>> constexpr optional& operator=(U&& v);

Constraints:

(14.1)
is_same_v<remove_cvref_t, optional> is false,
(14.2)
conjunction_v<is_scalar<T>, is_same<T, decay_t>> is false,
(14.3)
is_constructible_v<T, U> is true, and
(14.4)
is_assignable_v<T&, U> is true.

Effects: If *this contains a value, assigns std::forward(v) to val; otherwise direct-non-list-initializes val with std::forward(v).

Postconditions: *this contains a value.

Returns: *this.

Remarks: If any exception is thrown, the result of the expression this->has_value() remains unchanged.

If an exception is thrown during the call to T's constructor, the state of v is determined by the exception safety guarantee of T's constructor.

If an exception is thrown during the call to T's assignment, the states of val and v are determined by the exception safety guarantee of T's assignment.

🔗

template<class U> constexpr optional<T>& operator=(const optional<U>& rhs);

Constraints:

(19.1)
is_constructible_v<T, const U&> is true,
(19.2)
is_assignable_v<T&, const U&> is true,
(19.3)
converts-from-any-cvref<T, optional> is false,
(19.4)
is_assignable_v<T&, optional&> is false,
(19.5)
is_assignable_v<T&, optional&&> is false,
(19.6)
is_assignable_v<T&, const optional&> is false, and
(19.7)
is_assignable_v<T&, const optional&&> is false.

Effects: See Table 69 .

Table 69 — optional::operator=(const optional&) effects [tab:optional.assign.copy.templ]

🔗	*this contains a value	*this does not contain a value
🔗 rhs contains a value	assigns rhs.operator() to val*	direct-non-list-initializes val with rhs.operator*()
🔗 rhs does not contain a value	destroys the contained value by calling val.T::~T()	no effect

Postconditions: rhs.has_value() == this->has_value().

Returns: *this.

Remarks: If any exception is thrown, the result of the expression this->has_value() remains unchanged.

If an exception is thrown during the call to T's constructor, the state of rhs.val is determined by the exception safety guarantee of T's constructor.

If an exception is thrown during the call to T's assignment, the states of val and rhs.val are determined by the exception safety guarantee of T's assignment.

🔗

template<class U> constexpr optional<T>& operator=(optional<U>&& rhs);

Constraints:

(24.1)
is_constructible_v<T, U> is true,
(24.2)
is_assignable_v<T&, U> is true,
(24.3)
converts-from-any-cvref<T, optional> is false,
(24.4)
is_assignable_v<T&, optional&> is false,
(24.5)
is_assignable_v<T&, optional&&> is false,
(24.6)
is_assignable_v<T&, const optional&> is false, and
(24.7)
is_assignable_v<T&, const optional&&> is false.

Effects: See Table 70 .

The result of the expression rhs.has_value() remains unchanged.

Table 70 — optional::operator=(optional&&) effects [tab:optional.assign.move.templ]

🔗	*this contains a value	*this does not contain a value
🔗 rhs contains a value	assigns std::move(rhs).operator() to val*	direct-non-list-initializes val with std::move(rhs).operator*()
🔗 rhs does not contain a value	destroys the contained value by calling val.T::~T()	no effect

Postconditions: rhs.has_value() == this->has_value().

Returns: *this.

Remarks: If any exception is thrown, the result of the expression this->has_value() remains unchanged.

If an exception is thrown during the call to T's constructor, the state of rhs.val is determined by the exception safety guarantee of T's constructor.

If an exception is thrown during the call to T's assignment, the states of val and rhs.val are determined by the exception safety guarantee of T's assignment.

🔗

template<class... Args> constexpr T& emplace(Args&&... args);

Mandates: is_constructible_v<T, Args...> is true.

Effects: Calls *this = nullopt.

Then direct-non-list-initializes val with std::forward<Args>(args)....

Postconditions: *this contains a value.

Returns: val.

Throws: Any exception thrown by the selected constructor of T.

Remarks: If an exception is thrown during the call to T's constructor, *this does not contain a value, and the previous val (if any) has been destroyed.

🔗

template<class U, class... Args> constexpr T& emplace(initializer_list<U> il, Args&&... args);

Constraints: is_constructible_v<T, initializer_list&, Args...> is true.

Effects: Calls *this = nullopt.

Then direct-non-list-initializes val with il, std::forward<Args>(args)....

Postconditions: *this contains a value.

Returns: val.

Throws: Any exception thrown by the selected constructor of T.

Remarks: If an exception is thrown during the call to T's constructor, *this does not contain a value, and the previous val (if any) has been destroyed.