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

constexpr variant& operator=( const variant& rhs );	(1)	(начиная с C++17)
constexpr variant& operator=( variant&& rhs ) noexcept(/* see below */);	(2)	(начиная с C++17)
template< class T > variant& operator=( T&& t ) noexcept(/* see below */);	(3)	(начиная с C++17) (constexpr начиная с C++20)

Присваивает новое значение существующему объекту variant.

1) Копирующее присваивание:

Если оба *this и rhs не содержат значения из-за исключения, ничего не делает.
В противном случае, если rhs не содержит значения, а *this содержит, уничтожает значение, содержащееся в *this, и делает его не содержащим значения.
В противном случае, если rhs содержит ту же альтернативу, что и *this, присваивает значение, содержащееся в rhs, значению, содержащемуся в *this. Если возникает исключение, *this не перестаёт содержать значения: значение зависит от гарантии безопасности исключений копирующего присваивания альтернативы.
В противном случае, если альтернатива, содержащаяся в rhs, либо является nothrow copy constructible, либо не является nothrow move constructible (как определено std::is_nothrow_copy_constructible и std::is_nothrow_move_constructible, соответственно), эквивалентно this->emplace<rhs.index()>(*std::get_if<rhs.index()>(std::addressof(rhs))). *this может стать valueless_by_exception если при копирующем конструировании внутри emplace возникнет исключение.
В противном случае, эквивалентно this->operator=(variant(rhs)).

Эта перегрузка определена как удалённая, если только std::is_copy_constructible_v<T_i> и std::is_copy_assignable_v<T_i> не являются оба true для всех T_i в Types.... Эта перегрузка является тривиальной, если std::is_trivially_copy_constructible_v<T_i>,std::is_trivially_copy_assignable_v<T_i> и std::is_trivially_destructible_v<T_i> все являются true для всех T_i в Types....

2) Перемещающее присваивание:

Если оба *this и rhs не содержат значения из-за исключения, ничего не делает.
В противном случае, если rhs не содержит значения, а *this содержит, уничтожает значение, содержащееся в *this, и делает его не содержащим значения.
В противном случае, если rhs содержит ту же альтернативу, что и *this, присваивает std::move(*std::get_if<j>(std::addressof(rhs))) значению, содержащемуся в *this, где j является index(). Если возникает исключение, *this не перестаёт содержать значения: значение зависит от гарантии безопасности исключений перемещающего присваивания альтернативы.
В противном случае (если rhs и *this содержат разные альтернативы), эквивалентно this->emplace<rhs.index()>(std::move(*std::get_if<rhs.index()>(std::addressof(rhs)))). Если перемещающим конструктором T_i выбрасывается исключение, *this становится valueless_by_exception.

Эта перегрузка участвует в разрешении перегрузок только если std::is_move_constructible_v<T_i> и std::is_move_assignable_v<T_i> оба являются true для всех T_i в Types.... Эта перегрузка является тривиальной, если std::is_trivially_move_constructible_v<T_i>, std::is_trivially_move_assignable_v<T_i> и std::is_trivially_destructible_v<T_i> все являются true для всех T_i в Types....

3) Преобразующее присваивание.

Определяет тип альтернативы T_j, который был бы выбран разрешением перегрузок для выражения F(std::forward<T>(t)), если бы существовала перегрузка воображаемой функции F(T_i) для каждого T_i из Types..., находящаяся в области видимости в тот же момент, за исключением того, что:

Перегрузка F(T_i) рассматривается только если объявление T_i x[] = { std::forward<T>(t) }; допустимо для некоторой изобретённой переменной x;

Если *this уже содержит T_j, присваивает std::forward<T>(t) значению, содержащемуся в *this. Если возникает исключение, *this не перестаёт содержать значения: значение зависит от гарантии безопасности исключений вызванного присваивания.
В противном случае, если std::is_nothrow_constructible_v<T_j, T> || !std::is_nothrow_move_constructible_v<T_j> является true, эквивалентно this->emplace<j>(std::forward<T>(t)). *this может стать valueless_by_exception если при инициализации внутри emplace возникнет исключение.
В противном случае, эквивалентно this->emplace<j>(T_j(std::forward<T>(t))).

Эта перегрузка участвует в разрешении перегрузок только если std::decay_t<T>(до C++20)std::remove_cvref_t<T>(начиная с C++20) не является тем же типом, что и variant, и std::is_assignable_v<T_j&, T> является true, и std::is_constructible_v<T_j, T> является true, и выражение F(std::forward<T>(t)) (где F — указанный выше набор воображаемых функций) является корректным.

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

Параметры

rhs	-	another `variant`
t	-	значение, конвертируемое в один из вариантов variant

Возвращаемое значение

* this

Исключения

1) Может выбрасывать любое исключение, выбрасываемое присваиванием и копирующей/перемещающей инициализацией любого альтернативного типа.

2)

noexcept спецификация:

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

3)

noexcept спецификация:

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

Примечания

Макрос тестирования возможностей	Значение	Стандарт	Возможность
`__cpp_lib_variant`	`202106L`	(C++20) (DR)	Полностью constexpr `std::variant` ( 3 )

Пример

Запустить этот код

#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)>;
        if constexpr (std::is_same_v<T, int>)
            os << arg;
        else if constexpr (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';
}

Возможный вывод:

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 int
a: { 2019 };
(3) operator=( T&& t ), where T is std::string
s: "CppNow"
a: { "CppNow" };
s: ""

Отчеты о дефектах

Следующие отчеты об изменениях поведения, влияющие на дефекты, были применены ретроактивно к ранее опубликованным стандартам C++.

DR	Применяется к	Поведение в опубликованной версии	Корректное поведение
LWG 3024	C++17	оператор копирующего присваивания не участвует в разрешении перегрузки если любой тип члена не является копируемым	определяется как удаленный вместо этого
LWG 3585	C++17	преобразующее присваивание иногда было неожиданно некорректным потому что не было доступного оператора перемещающего присваивания	сделано корректным
P0602R4	C++17	копирующее/перемещающее присваивание может не быть тривиальным даже если базовые операции тривиальны	требуется распространение тривиальности
P0608R3	C++17	преобразующее присваивание слепо собирает набор перегрузок, приводя к непреднамеренным преобразованиям	сужающие и булевы преобразования не рассматриваются
P2231R1	C++20	преобразующее присваивание ( 3 ) не было constexpr в то время как требуемые операции могут быть constexpr в C++20	сделано constexpr

Смотрите также

emplace

создаёт значение внутри


          variant

, на месте
(публичная функция-член)

Поддержка компиляторов
Автономные и хостируемые реализации
Язык
Стандартная библиотека
Заголовки стандартной библиотеки
Именованные требования
Макросы проверки возможностей (C++20)
Библиотека поддержки языка
Библиотека концептов (C++20)
Библиотека диагностики
Библиотека управления памятью
Библиотека метапрограммирования (C++11)
Библиотека общих утилит
Библиотека контейнеров
Библиотека итераторов
Библиотека диапазонов (C++20)
Библиотека алгоритмов
Библиотека строк
Библиотека обработки текста
Библиотека численных методов
Библиотека даты и времени
Библиотека ввода/вывода
Библиотека файловой системы (C++17)
Библиотека поддержки конкурентности (C++11)
Библиотека управления выполнением (C++26)
Технические спецификации
Указатель символов
Внешние библиотеки

Функции-элементы
variant::variant
variant::~variant
variant::operator=
Наблюдатели
variant::index
variant::valueless_by_exception
Модификаторы
variant::emplace
variant::swap
Посещение
variant::visit (C++26)
Свободные функции
visit(std::variant)
holds_alternative
get(std::variant)
get_if
operator==operator!=operator<operator<=operator>operator>=operator<=> (C++20)
swap(std::variant)
Вспомогательные классы
monostate
bad_variant_access
variant_size
variant_alternative
hash<std::variant>
Вспомогательные объекты
variant_npos

ru.cppreference.net

Namespaces

Variants