Namespaces
Variants

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

From cppreference.net
C++
Utilities library
std::variant
constexpr variant & operator = ( const variant & rhs ) ;
(1) (начиная с C++17)
constexpr variant & operator = ( variant && rhs ) noexcept ( /* см. ниже */ ) ;
(2) (начиная с C++17)
template < class T >
variant & operator = ( T && t ) noexcept ( /* см. ниже */ ) ;
(3) (начиная с C++17)
(constexpr начиная с C++20)

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

1) Копирующее присваивание:
  • Если и * this , и rhs являются безначными по исключению, ничего не делает.
  • Иначе, если rhs безначный, но * this не является, уничтожает значение, содержащееся в * this , и делает его безначным.
  • Иначе, если rhs содержит ту же альтернативу, что и * this , присваивает значение, содержащееся в rhs , значению, содержащемуся в * this . Если выбрасывается исключение, * this не становится безначным: значение зависит от гарантии безопасности исключений копирующего присваивания альтернативы.
  • Иначе, если альтернатива, содержащаяся в rhs , является либо безысключительной копируемо конструируемой, либо не является безысключительной перемещаемо конструируемой (определяется с помощью 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) Converting assignment.
  • Определяет альтернативный тип 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"; // Ошибка
std::variant <std::string, bool> v3;
v3 = "abc"; // OK, выбирает string; bool не является кандидатом
std::variant<float, long, double> v4; // содержит float
v4 = 0; // OK, содержит long; float и double не являются кандидатами

Содержание

Параметры

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

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

создаёт значение внутри variant , на месте
(публичная функция-член)