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

constexpr variant& operator=( const variant& rhs );

constexpr variant& operator=( variant&& rhs ) noexcept(/* see below */);

template< class T > 
variant& operator=( T&& t ) noexcept(/* see below */);

template< class T > 
constexpr variant& operator=( T&& t ) noexcept(/* see below */);

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

• Если оба *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)).

• Если оба *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.

• Определяет тип варианта 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

Параметры

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

*this

Исключения

Пример

#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++.

См. также