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 */);

Присваивает новое значение существующему объекту 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)), если бы для каждого T_i из Types... в области видимости одновременно находилась перегрузка воображаемой функции F(T_i), за исключением следующих условий:
• Перегрузка 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

Исключения

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

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

Примечания

Пример

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

См. также