7.1 KiB
[variant.assign]
22 General utilities library [utilities]
22.6 Variants [variant]
22.6.3 Class template variant [variant.variant]
22.6.3.4 Assignment [variant.assign]
constexpr variant& operator=(const variant& rhs);
Let j be rhs.index().
Effects:
-
If neither *this nor rhs holds a value, there is no effect.
-
Otherwise, if *this holds a value but rhs does not, destroys the value contained in *this and sets *this to not hold a value.
-
Otherwise, if index() == j, assigns the value contained in rhs to the value contained in *this.
-
Otherwise, if either is_nothrow_copy_constructible_v is true oris_nothrow_move_constructible_v is false, equivalent to emplace(GET(rhs)).
-
Otherwise, equivalent to operator=(variant(rhs)).
Postconditions: index() == rhs.index().
Returns: *this.
Remarks: This operator is defined as deleted unlessis_copy_constructible_v &&is_copy_assignable_v is true for all i.
If is_trivially_copy_constructible_v &&is_trivially_copy_assignable_v &&is_trivially_destructible_v 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 &&is_move_assignable_v istrue for all i.
Effects:
-
If neither *this nor rhs holds a value, there is no effect.
-
Otherwise, if *this holds a value but rhs does not, destroys the value contained in *this and sets *this to not hold a value.
-
Otherwise, if index() == j, assigns GET(std::move(rhs)) to the value contained in *this.
-
Otherwise, equivalent to emplace(GET(std::move(rhs))).
Returns: *this.
Remarks: If is_trivially_move_constructible_v &&is_trivially_move_assignable_v &&is_trivially_destructible_v is true for all i, this assignment operator is trivial.
The exception specification is equivalent tois_nothrow_move_constructible_v && is_nothrow_move_assignable_v for all i.
-
If an exception is thrown during the call to Tj's move construction (with j being rhs.index()), the variant will hold no value.
-
If an exception is thrown during the call to Tj's move assignment, the state of the contained value is as defined by the exception safety guarantee of Tj's move assignment; index() will be j.
template<class T> constexpr variant& operator=(T&& t) noexcept(see below);
Let Tj be a type that is determined as follows: build an imaginary function FUN(Ti) for each alternative type Ti for which Ti x[] = {std::forward(t)}; is well-formed for some invented variable x.
The overload FUN(Tj) selected by overload resolution for the expression FUN(std::forward(t)) defines the alternative Tj which is the type of the contained value after assignment.
Constraints:
is_same_v<remove_cvref_t, variant> is false,
is_assignable_v<Tj&, T> && is_constructible_v<Tj, T> is true, and
the expression FUN(std::forward(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:
-
If *this holds a Tj, assigns std::forward(t) to the value contained in *this.
-
Otherwise, if is_nothrow_constructible_v<Tj, T> ||!is_nothrow_move_constructible_v is true, equivalent to emplace(std::forward(t)).
-
Otherwise, equivalent to emplace(Tj(std::forward(t))).
Postconditions: holds_alternative(*this) is true, with Tj selected by the imaginary function overload resolution described above.
Returns: *this.
Remarks: The exception specification is equivalent to:is_nothrow_assignable_v<Tj&, T> && is_nothrow_constructible_v<Tj, T>
-
If an exception is thrown during the assignment of std::forward(t) to the value contained in *this, the state of the contained value andt are as defined by the exception safety guarantee of the assignment expression; valueless_by_exception() will be false.
-
If an exception is thrown during the initialization of the contained value, the variant object is permitted to not hold a value.