std::variant::operator=

variant& operator=(const variant& rhs);	(1)	(since C++17)
variant& operator=(variant&& rhs) noexcept(/* see below */);	(2)	(since C++17)
template <class T> variant& operator=(T&& t) noexcept(/* see below */);	(3)	(since C++17)

Assigns a new value to an existing variant object

1) Copy-assignment:

If both *this and rhs are valueless by exception, does nothing.
Otherwise, if rhs is valueless, but *this is not, destroys the value contained in *this and makes it valueless.
Otherwise, if rhs holds the same alternative as *this, assigns the value contained in rhs to the value contained in *this. If an exception is thrown, *this does not become valueless: the value depends on the exception safety guarantee of the alternative's copy assignment.
Otherwise, if the alternative held by other is either nothrow copy constructible or not nothrow move constructible (as determined by std::is_nothrow_copy_constructible and std::is_nothrow_move_constructible, respectively), equivalent to this->emplace<other.index()>(get<other.index()>(other)).
Otherwise, equivalent to this->operator=(variant(rhs)).

This overload is defined as deleted unless std::is_copy_constructible_v<T_i> && std::is_copy_assignable_v<T_i> is true for all T_i in Types....

2) Move-assignment:

If both *this and rhs are valueless by exception, does nothing
Otherwise, if rhs is valueless, but *this is not, destroys the value contained in *this and makes it valueless
Otherwise, if rhs holds the same alternative as *this, assigns std::get<j>(std::move(rhs)) to the value contained in *this, with j being index(). If an exception is thrown, *this does not become valueless: the value depends on the exception safety guarantee of the alternative's move assignment.
Otherwise (if rhs and *this hold different alternatives), equivalent to this->emplace<other.index()>(get<other.index()>(std::move(other))). If an exception is thrown by T_i's move constructor, *this becomes valueless_by_exception.

This overload only participates in overload resolution if std::is_move_constructible_v<T_i> && std::is_move_assignable_v<T_i> is true for all T_i in Types....

3) Converting assignment.

Determines the alternative type T_j that would be selected by overload resolution for the expression F(std::forward<T>(t)) if there was an overload of imaginary function F(T_i) for every T_i from Types... in scope at the same time.
If *this already holds a T_j, assigns std::forward<T>(t) to the value contained in *this. If an exception is thrown, *this does not become valueless: the value depends on the exception safety guarantee of the assignment called.
Otherwise, if std::is_nothrow_constructible_v<T_j, T> || !std::is_nothrow_move_constructible_v<T_j> is true, equivalent to this->emplace<j>(std::forward<T>(t));
Otherwise, equivalent to this->operator=(variant(std::forward<T>(t))).

This overload only participates in overload resolution if std::decay_t<T> (until C++20)std::remove_cvref_t<T> (since C++20) is not the same type as variant and std::is_assignable_v<T_j&, T> is true and std::is_constructible_v<T_j, T> is true and the expression F(std::forward<T>(t)) (with F being the above-mentioned set of imaginary functions) is well formed

variant<string> v1;
v1 = "abc"; // OK
variant<string, string> v2;
v2 = "abc"; // Error
variant <string, bool> v3;
v3 = "abc"; // OK but chooses bool

Parameters

rhs	-	another `variant`
t	-	a value convertible to one of the variant's alternatives

Return value

*this

Exceptions

1) May throw any exception thrown by assignment and copy/move initialization of any alternative

2)

noexcept specification:

noexcept(((std::is_nothrow_move_constructible_v<Types> && std::is_nothrow_move_assignable_v<Types>) && ...))

3)

noexcept specification:

noexcept(std::is_nothrow_assignable_v<T_j&, T> && std::is_nothrow_constructible_v<T_j, T>)

Example

Defect reports

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

DR	Applied to	Behavior as published	Correct behavior
LWG 3024	C++17	copy assignment operator doesn't participate in overload resolution if any member type is not copyable	defined as deleted instead

Language
Headers
Freestanding and hosted implementations
Named requirements
Language support library
Concepts library (C++20)
Diagnostics library
Utilities library
Strings library
Containers library
Algorithms library
Iterators 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