Namespaces

• Page
• Discussion

Variants

Views

• View
• Edit
• History

Actions

• If both*this andrhs are valueless by exception, does nothing.
• Otherwise, ifrhs is valueless, but*this is not, destroys the value contained in*this and makes it valueless.
• Otherwise, ifrhs holds the same alternative as*this, assigns the value contained inrhs 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 byrhs is either nothrow copy constructible ornot nothrow move constructible (as determined bystd::is_nothrow_copy_constructible andstd::is_nothrow_move_constructible, respectively), equivalent tothis->emplace<rhs.index()>(*std::get_if<rhs.index()>(std::addressof(rhs))).*this may becomevalueless_by_exception if an exception is thrown on the copy-construction insideemplace.
• Otherwise, equivalent tothis->operator=(variant(rhs)).

• If both*this andrhs are valueless by exception, does nothing.
• Otherwise, ifrhs is valueless, but*this is not, destroys the value contained in*this and makes it valueless.
• Otherwise, ifrhs holds the same alternative as*this, assignsstd::move(*std::get_if<j>(std::addressof(rhs))) to the value contained in*this, withj beingindex(). 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 (ifrhs and*this hold different alternatives), equivalent tothis->emplace<rhs.index()>(std::move(*std::get_if<rhs.index()>(std::addressof(rhs)))). If an exception is thrown byT_i's move constructor,*this becomesvalueless_by_exception.

• Determines the alternative typeT_j that would be selected by overload resolution for the expressionF(std::forward<T>(t)) if there was an overload of imaginary functionF(T_i) for everyT_i fromTypes... in scope at the same time, except that:

• An overloadF(T_i) is only considered if the declarationT_i x[]={std::forward<T>(t)}; is valid for some invented variablex;

• If*this already holds aT_j, assignsstd::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, ifstd::is_nothrow_constructible_v<T_j, T>||!std::is_nothrow_move_constructible_v<T_j> istrue, equivalent tothis->emplace<j>(std::forward<T>(t)).*this may becomevalueless_by_exception if an exception is thrown on the initialization insideemplace.
• Otherwise, equivalent tothis->emplace<j>(T_j(std::forward<T>(t))).

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

std::variant<std::string> v1;v1="abc";// OKstd::variant<std::string,std::string> v2;v2="abc";// Errorstd::variant<std::string,bool> v3;v3="abc";// OK, chooses string; bool is not a candidatestd::variant<float,long,double> v4;// holds floatv4=0;// OK, holds long; float and double are not candidates

#include <iomanip>#include <iostream>#include <string>#include <type_traits>#include <variant> std::ostream& operator<<(std::ostream& os,std::variant<int,std::string>const& va){    os<<": { "; std::visit([&](auto&& arg){using T=std::decay_t<decltype(arg)>;ifconstexpr(std::is_same_v<T,int>)            os<< arg;elseifconstexpr(std::is_same_v<T,std::string>)            os<<std::quoted(arg);}, va); return os<<" };\n";} int main(){std::variant<int,std::string> a{2017}, b{"CppCon"};std::cout<<"a"<< a<<"b"<< b<<'\n'; std::cout<<"(1) operator=( const variant& rhs )\n";    a= b;std::cout<<"a"<< a<<"b"<< b<<'\n'; std::cout<<"(2) operator=( variant&& rhs )\n";    a= std::move(b);std::cout<<"a"<< a<<"b"<< b<<'\n'; std::cout<<"(3) operator=( T&& t ), where T is int\n";    a=2019;std::cout<<"a"<< a<<'\n'; std::cout<<"(3) operator=( T&& t ), where T is std::string\n";std::string s{"CppNow"};std::cout<<"s: "<<std::quoted(s)<<'\n';    a= std::move(s);std::cout<<"a"<< a<<"s: "<<std::quoted(s)<<'\n';}

Possible output:

a: { 2017 };b: { "CppCon" }; (1) operator=( const variant& rhs )a: { "CppCon" };b: { "CppCon" }; (2) operator=( variant&& rhs )a: { "CppCon" };b: { "" }; (3) operator=( T&& t ), where T is inta: { 2019 }; (3) operator=( T&& t ), where T is std::strings: "CppNow"a: { "CppNow" };s: ""