std::variant<Types...>::operator=

• Si tanto *this como rhs no tienen valor por excepción, no hace nada.
• En caso contrario, si rhs no tiene valor, pero *this sí, destruye el valor contenido en *this y lo deja sin valor.
• En caso contrario, si rhs tiene la misma alternativa que *this, asigna el valor contenido en rhs al valor contenido en *this. Si se lanza una excepción, *this no se queda sin valor: el valor depende de la garantía de seguridad ante excepciones de la copia-asignación de la alternativa.
• En caso contrario, si la alternativa contenida por rhs no es construible por copia sin lanzar excepciones o no es construible por movimiento sin lanzar excepciones (según lo determina std::is_nothrow_copy_constructible y std::is_nothrow_move_constructible, respectivamente), equivale a this->emplace<rhs.index()>(*std::get_if<rhs.index()>(std::addressof(rhs))). *this puede quedar valueless_by_exception sin valor si se lanza una excepción durante la construcción por copia dentro de emplace.
• En caso contrario, equivale a this->operator=(variant(rhs)).

• Si tanto *this como rhs no tienen valor por excepción, no hace nada.
• En caso contrario, si rhs no tiene valor, pero *this sí, destruye el valor contenido en *this y lo deja sin valor.
• En caso contrario, si rhs tiene la misma alternativa que *this, asigna std::move(*std::get_if<j>(std::addressof(rhs))) al valor contenido en *this, siendo j index(). Si se lanza una excepción, *this no se queda sin valor: el valor depende de la garantía de seguridad ante excepciones de la movimiento-asignación de la alternativa.
• En caso contrario (si rhs y *this tienen alternativas diferentes), equivale a this->emplace<rhs.index()>(std::move(*std::get_if<rhs.index()>(std::addressof(rhs)))). Si el constructor de movimiento de T_i lanza una excepción, *this se convierte en valueless_by_exception.

• Determina el tipo de alternativa T_j que sería seleccionado por resolución de sobrecarga para la expresión F(std::forward<T>(t)) si hubiera una sobrecarga de la función imaginaria F(T_i) para cada T_i de Types... en el ámbito al mismo tiempo, excepto que:

• Una sobrecarga F(T_i) solo se considera si la declaración T_i x[] = { std::forward<T>(t) }; es válida para alguna variable inventada x;

• Si *this ya contiene un T_j, asigna std::forward<T>(t) al valor contenido en *this. Si se lanza una excepción, *this no se queda sin valor: el valor depende de la garantía de seguridad ante excepciones de la asignación llamada.
• En caso contrario, si std::is_nothrow_constructible_v<T_j, T> || !std::is_nothrow_move_constructible_v<T_j> es true, equivale a this->emplace<j>(std::forward<T>(t)). *this puede quedar valueless_by_exception sin valor si se lanza una excepción durante la inicialización dentro de emplace.
• En caso contrario, equivale a this->emplace<j>(T_j(std::forward<T>(t))).

Esta sobrecarga participa en la resolución de sobrecargas solo si std::decay_t<T>(hasta C++20)std::remove_cvref_t<T>(desde C++20) no es del mismo tipo que variant y std::is_assignable_v<T_j&, T> es true y std::is_constructible_v<T_j, T> es true y la expresión F(std::forward<T>(t)) (siendo F el conjunto de funciones imaginarias mencionado anteriormente) está bien formada.

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