20 General utilities library [utilities]

20.7 Variants [variant]

20.7.3 Class template variant [variant.variant]

20.7.3.4 Assignment [variant.assign]

constexpr variant& operator=(const variant& rhs);

Let j be rhs.index().

Effects:

(2.1)
If neither *this nor rhs holds a value, there is no effect.
(2.2)
Otherwise, if *this holds a value but rhs does not, destroys the value contained in *this and sets *this to not hold a value.
(2.3)
Otherwise, if index() == j, assigns the value contained in rhs to the value contained in *this.
(2.4)
Otherwise, if either is_nothrow_copy_constructible_v< $T_{j}$ > is true or is_nothrow_move_constructible_v< $T_{j}$ > is false, equivalent to emplace<j>(get<j>(rhs)).
(2.5)
Otherwise, equivalent to operator=(variant(rhs)).

Postconditions: index() == rhs.index().

Returns: *this.

Remarks: This operator is defined as deleted unless is_copy_constructible_v<

T_{i}

> && is_copy_assignable_v<

T_{i}

> is true for all i.

If is_trivially_copy_constructible_v<

T_{i}

> && is_trivially_copy_assignable_v<

T_{i}

> && is_trivially_destructible_v<

T_{i}

> is true for all i, this assignment operator is trivial.

🔗

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

Let j be rhs.index().

Constraints: is_move_constructible_v<

T_{i}

> && is_move_assignable_v<

T_{i}

> is true for all i.

Effects:

(8.1)
If neither *this nor rhs holds a value, there is no effect.
(8.2)
Otherwise, if *this holds a value but rhs does not, destroys the value contained in *this and sets *this to not hold a value.
(8.3)
Otherwise, if index() == j, assigns get<j>(std::move(rhs)) to the value contained in *this.
(8.4)
Otherwise, equivalent to emplace<j>(get<j>(std::move(rhs))).

Returns: *this.

Remarks: If is_trivially_move_constructible_v<

T_{i}

> && is_trivially_move_assignable_v<

T_{i}

> && is_trivially_destructible_v<

T_{i}

> is true for all i, this assignment operator is trivial.

The expression inside noexcept is equivalent to is_nothrow_move_constructible_v<

T_{i}

> && is_nothrow_move_assignable_v<

T_{i}

> for all i.

(10.1)
If an exception is thrown during the call to $T_{j}$ 's move construction (with j being rhs.index()), the variant will hold no value.
(10.2)
If an exception is thrown during the call to $T_{j}$ 's move assignment, the state of the contained value is as defined by the exception safety guarantee of $T_{j}$ 's move assignment; index() will be j.

🔗

template<class T> variant& operator=(T&& t) noexcept(see below);

Let

T_{j}

be a type that is determined as follows: build an imaginary function FUN(

T_{i}

) for each alternative type

T_{i}

for which

T_{i}

x[] = {std::forward<T>(t)}; is well-formed for some invented variable x.

The overload FUN(

T_{j}

) selected by overload resolution for the expression FUN(std::forward<T>(t)) defines the alternative

T_{j}

which is the type of the contained value after assignment.

Constraints:

(12.1)
is_same_v<remove_cvref_t<T>, variant> is false,
(12.2)
is_assignable_v< $T_{j}$ &, T> && is_constructible_v< $T_{j}$ , T> is true, and
(12.3)
the expression FUN(std::forward<T>(t)) (with FUN being the above-mentioned set of imaginary functions) is well-formed.
[Note 1:
variant<string, string> v; v = "abc"; is ill-formed, as both alternative types have an equally viable constructor for the argument.
— end note]

Effects:

(13.1)
If *this holds a $T_{j}$ , assigns std::forward<T>(t) to the value contained in *this.
(13.2)
Otherwise, if is_nothrow_constructible_v< $T_{j}$ , T> || !is_nothrow_move_constructible_v< $T_{j}$ > is true, equivalent to emplace<j>(std::forward<T>(t)).
(13.3)
Otherwise, equivalent to operator=(variant(std::forward<T>(t))).

Postconditions: holds_alternative<

T_{j}

>(*this) is true, with

T_{j}

selected by the imaginary function overload resolution described above.

Returns: *this.

Remarks: The expression inside noexcept is equivalent to: is_nothrow_assignable_v<T

_{j}

&, T> && is_nothrow_constructible_v<T

_{j}

, T>

(16.1)
If an exception is thrown during the assignment of std::forward<T>(t) to the value contained in *this, the state of the contained value and t are as defined by the exception safety guarantee of the assignment expression; valueless_by_exception() will be false.
(16.2)
If an exception is thrown during the initialization of the contained value, the variant object is permitted to not hold a value.