23 General utilities library [utilities]

Let j be rhs.index().

Effects:

• (2.1)

  If neither *this nor rhs holds a value, there is no effect. Otherwise,

• (2.2)

  if *this holds a value but rhs does not, destroys the value contained in *this and sets *this to not hold a value. Otherwise,

• (2.3)

  if index() == j, assigns the value contained in rhs to the value contained in *this. Otherwise,

• (2.4)

  if either is_­nothrow_­copy_­constructible_­v<${\text{T}}_j$> or !is_­nothrow_­move_­constructible_­v<${\text{T}}_j$> is true, equivalent to emplace<j>(get<j>(rhs)). Otherwise,

• (2.5)

  equivalent to operator=(variant(rhs)).

Returns: *this.

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

Remarks: This function shall not participate in overload resolution unless is_­copy_­constructible_­v<${\text{T}}_i$> && is_­copy_­assignable_­v<${\text{T}}_i$> is true for all i.

Let j be rhs.index().

Effects:

• (7.1)

  If neither *this nor rhs holds a value, there is no effect. Otherwise,

• (7.2)

  if *this holds a value but rhs does not, destroys the value contained in *this and sets *this to not hold a value. Otherwise,

• (7.3)

  if index() == j, assigns get<j>(std​::​move(rhs)) to the value contained in *this. Otherwise,

• (7.4)

  equivalent to emplace<j>(get<j>(std​::​move(rhs))).

Returns: *this.

Remarks: This function shall not participate in overload resolution unless is_­move_­constructible_­v<${\text{T}}_i$> && is_­move_­assignable_­v<${\text{T}}_i$> is true for all i. The expression inside noexcept is equivalent to: is_­nothrow_­move_­constructible_­v<${\text{T}}_i$> && is_­nothrow_­move_­assignable_­v<${\text{T}}_i$> for all i.

• (9.1)

  If an exception is thrown during the call to ${\text{T}}_j$'s move construction (with j being rhs.index()), the variant will hold no value.

• (9.2)

  If an exception is thrown during the call to ${\text{T}}_j$'s move assignment, the state of the contained value is as defined by the exception safety guarantee of ${\text{T}}_j$'s move assignment; index() will be j.

Let ${\text{T}}_j$ be a type that is determined as follows: build an imaginary function FUN(${\text{T}}_i$) for each alternative type ${\text{T}}_i$. The overload FUN(${\text{T}}_j$) selected by overload resolution for the expression FUN(std​::​forward<T>(​t)) defines the alternative ${\text{T}}_j$ which is the type of the contained value after assignment.

Effects:

• (11.1)

  If *this holds a ${\text{T}}_j$, assigns std​::​forward<T>(t) to the value contained in *this. Otherwise,

• (11.2)

  if is_­nothrow_­constructible_­v<${\text{T}}_j$, T> || !is_­nothrow_­move_­constructible_­v<${\text{T}}_j$> is true, equivalent to emplace<j>(std​::​forward<T>(t)). Otherwise,

• (11.3)

  equivalent to operator=(variant(std​::​forward<T>(t))).

Postconditions: holds_­alternative<${\text{T}}_j$>(*this) is true, with ${\text{T}}_j$ selected by the imaginary function overload resolution described above.

Returns: *this.

Remarks: This function shall not participate in overload resolution unless is_­same_­v<decay_­t<T>, variant> is false, unless is_­assignable_­v<${\text{T}}_j$&, T> && is_­constructible_­v<${\text{T}}_j$, T> is true, and unless the expression FUN(std​::​forward<T>(t)) (with FUN being the above-mentioned set of imaginary functions) is well formed.

[ Note:

variant<string, string> v;
v = "abc";

is ill-formed, as both alternative types have an equally viable constructor for the argument.  — end note ]

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 might not hold a value.