std::variant::variant
From cppreference.com
| constexpr variant() noexcept(/* see below */); |
(1) | (since C++17) |
| constexpr variant(const variant& other); |
(2) | (since C++17) |
| constexpr variant(variant&& other) noexcept(/* see below */); |
(3) | (since C++17) |
| template< class T > constexpr variant(T&& t) noexcept(/* see below */); |
(4) | (since C++17) |
| template< class T, class... Args > constexpr explicit variant(std::in_place_type_t<T>, Args&&... args); |
(5) | (since C++17) |
| template< class T, class U, class... Args > constexpr explicit variant(std::in_place_type_t<T>, |
(6) | (since C++17) |
| template< std::size_t I, class... Args > constexpr explicit variant(std::in_place_index_t<I>, Args&&... args); |
(7) | (since C++17) |
| template< std::size_t I, class U, class... Args > constexpr explicit variant(std::in_place_index_t<I>, |
(8) | (since C++17) |
Constructs a new variant object.
1) Default constructor. Constructs a variant holding the value-initialized value of the first alternative (index() is zero). This constructor is
constexpr if and only if the value initialization of the alternative type T_0 would satisfy the requirements for a constexpr function. This overload only participates in overload resolution if std::is_default_constructible_v<T_0> is true.2) Copy constructor. If
other is not valueless_by_exception, constructs a variant holding the same alternative as other and direct-initializes the contained value with std::get<other.index()>(other). Otherwise, initializes a valueless_by_exception variant. This constructor is defined as deleted unless std::is_copy_constructible_v<T_i> is true for all T_i in Types.... It is trivial if std::is_trivially_copy_constructible_v<T_i> is true for all T_i in Types....3) Move constructor. If
other is not valueless_by_exception, constructs a variant holding the same alternative as other and direct-initializes the contained value with std::get<other.index()>(std::move(other)). Otherwise, initializes a valueless_by_exception variant. This overload only participates in overload resolution if std::is_move_constructible_v<T_i> is true for all T_i in Types.... It is trivial if std::is_trivially_move_constructible_v<T_i> is true for all T_i in Types....4) Converting constructor. Constructs a variant holding the alternative type
T_j that would be selected by overload resolution for the expression F(std::forward<T>(t)) if there was an overload of imaginary function F(T_i) for every T_i from Types... in scope at the same time, except that:
- An overload F(T_i) is only considered if the declaration T_i x[] = { std::forward<T>(t) }; is valid for some invented variable
x; - If
T_iis (possibly cv-qualified) bool, F(T_i) is only considered if std:remove_cvref_t<T> is also bool.
- An overload F(T_i) is only considered if the declaration T_i x[] = { std::forward<T>(t) }; is valid for some invented variable
Direct-initializes the contained value as if by direct non-list-initialization from std::forward<T>(t). This overload only participates in overload resolution if sizeof...(Types) > 0, std::decay_t<U> (until C++20)std::remove_cvref_t<U> (since C++20) is neither the same type as variant, nor a specialization of std::in_place_type_t, nor a specialization of std::in_place_index_t, std::is_constructible_v<T_j, T> is
true, and the expression F(std::forward<T>(t)) (with F being the above-mentioned set of imaginary functions) is well formed. This constructor is a constexpr constructor if T_j's selected constructor is a constexpr constructor.
std::variant<std::string> v("abc"); // OK std::variant<std::string, std::string> w("abc"); // ill-formed std::variant<std::string, const char*> x("abc"); // OK, chooses const char* std::variant<std::string, bool> y("abc"); // OK, chooses string; bool is not a candidate std::variant<float, long, double> z = 0; // OK, holds long // float and double are not candidates
5) Constructs a variant with the specified alternative
T and initializes the contained value with the arguments std::forward<Args>(args).... If T's selected constructor is a constexpr constructor, this constructor is also a constexpr constructor. This overload only participates in overload resolution if there is exactly one occurrence of T in Types... and std::is_constructible_v<T, Args...> is true.6) Constructs a variant with the specified alternative
T and initializes the contained value with the arguments il, std::forward<Args>(args)..... If T's selected constructor is a constexpr constructor, this constructor is also a constexpr constructor. This overload only participates in overload resolution if there is exactly one occurrence of T in Types... and std::is_constructible_v<T, initializer_list<U>&, Args...> is true.7) Constructs a variant with the alternative T_i specified by the index
I and initializes the contained value with the arguments std::forward<Args>(args).... If T_i's selected constructor is a constexpr constructor, this constructor is also a constexpr constructor. This overload only participates in overload resolution if I < sizeof...(Types) and std::is_constructible_v<T_i, Args...> is true. 8) Constructs a variant with the alternative T_i specified by the index
I and initializes the contained value with the arguments il, std::forward<Args>(args).... If T_i's selected constructor is a constexpr constructor, this constructor is also a constexpr constructor. This overload only participates in overload resolution if I < sizeof...(Types) and std::is_constructible_v<T_i, std::initializer_list<U>&, Args...> is true. Parameters
| other | - | another variant object whose contained value to copy/move
|
| t | - | value to initialize the contained value with |
| args... | - | arguments to initialize the contained value with |
| il | - | initializer list to initialize the contained value with |
Exceptions
1) May throw any exception thrown by the value initialization of the first alternative.
noexcept specification:
noexcept(std::is_nothrow_default_constructible_v<T_0>)
2) May throw any exception thrown by direct-initializing any T_i in
Types...3) May throw any exception thrown by move-constructing any T_i in
Types.... noexcept specification:
noexcept( (std::is_nothrow_move_constructible_v<Types> && ...))
4) May throw any exception thrown by the initialization of the selected alternative
T_j. noexcept specification:
noexcept(std::is_nothrow_constructible_v<T_j, T>)
5-8) May throw any exception thrown by calling the selected constructor of the selected alternative
Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
| DR | Applied to | Behavior as published | Correct behavior |
|---|---|---|---|
| LWG 2901 | C++17 | allocator-aware constructors provided but variant can't properly support allocators
|
constructors removed |
| P0739R0 | C++17 | converting constructor template interacts poorly with class template argument deduction | constraint added |
| LWG 3024 | C++17 | copy constructor doesn't participate in overload resolution if any member type is not copyable | defined as deleted instead |
| P0602R4 | C++17 | copy/move constructors may not be trivial even if underlying constructors are trivial | required to propagate triviality |
| P0608R3 | C++17 | converting constructor blindly assembles an overload set, leading to unintended conversions | narrowing and boolean conversions not considered |
Example
| This section is incomplete Reason: no example |