[variant.ctor]

🔗

constexpr variant() noexcept(see below);

Throws: Any exception thrown by the value-initialization of

T {0 .}_{0 .}

Remarks: This function is constexpr if and only if the value-initialization of the alternative type

T {0 would be constexpr-suitable ([dcl. constexpr]) .}_{0 would be constexpr-suitable ([dcl. constexpr]) .}

The exception specification is equivalent to is_nothrow_default_constructible_v<

T {0 > .}_{0 >}

[Note 1:

See also class monostate.

— end note]

🔗

constexpr variant(const variant& w) noexcept(see below);

Effects: If w holds a value, initializes the variant to hold the same alternative as w and direct-initializes the contained value with GET<j>(w), where j is w.index().

Otherwise, initializes the variant to not hold a value.

Remarks: This constructor is defined as deleted unless is_copy_constructible_v<

T {i > is true for all i .}_{i >}

If is_trivially_copy_constructible_v<

T {i > is true for all i, this constructor is trivial .}_{i >}

The exception specification is equivalent to the logical and of is_nothrow_copy_constructible_v<

T {i > for all i .}_{i >}

🔗

constexpr variant(variant&& w) noexcept(see below);

Effects: If w holds a value, initializes the variant to hold the same alternative as w and direct-initializes the contained value with GET<j>(std::move(w)), where j is w.index().

Otherwise, initializes the variant to not hold a value.

Remarks: The exception specification is equivalent to the logical and of is_nothrow_move_constructible_v<

T {i > for all i .}_{i >}

If is_trivially_move_constructible_v<

T {i > is true for all i, this constructor is trivial .}_{i >}

🔗

template<class T> constexpr variant(T&& t) noexcept(see below);

Let

T {j be a type that is determined as follows: build an imaginary function FUN (T {i) for each alternative type T {i for which T {i x [] = {std ​::​ forward < T > (t)}; is well-formed for some invented variable x .}_{i x [] =}}_{i for which T {i x [] = {std ​::​ forward < T > (t)}; is well-formed for some invented variable x .}_{i x [] =}}}_{i)}}_{j be a type that is determined as follows: build an imaginary function FUN (T {i) for each alternative type T {i for which T {i x [] = {std ​::​ forward < T > (t)}; is well-formed for some invented variable x .}_{i x [] =}}_{i for which T {i x [] = {std ​::​ forward < T > (t)}; is well-formed for some invented variable x .}_{i x [] =}}}_{i)}}

The overload FUN(

T {j) selected by overload resolution for the expression FUN (std ​::​ forward < T > (​t)) defines the alternative T {j which is the type of the contained value after construction .}_{j which is the type of the contained value after construction .}}_{j)}

Constraints:

(15.1)
sizeof.(Types) is nonzero,
(15.2)
is_same_v<remove_cvref_t<T>, variant> is false,
(15.3)
remove_cvref_t<T> is neither a specialization of in_place_type_t nor a specialization of in_place_index_t,
(15.4)
is_constructible_v< $T {j, T > is true, and}_{j, T >}$
(15.5)
the expression FUN(std::forward<T>(t)) (with FUN being the above-mentioned set of imaginary functions) is well-formed.
[Note 2:
variant<string, string> v("abc"); is ill-formed, as both alternative types have an equally viable constructor for the argument.
— end note]

Effects: Initializes *this to hold the alternative type

T {j and direct-non-list-initializes the contained value with std ​::​ forward < T > (t) .}_{j and direct-non-list-initializes the contained value with std ​::​ forward < T > (t) .}

Remarks: The exception specification is equivalent to is_nothrow_constructible_v<

T {j, T > .}_{j, T >}

T {j's selected constructor is a constexpr constructor, this constructor is a constexpr constructor .}_{j's selected constructor is a constexpr constructor, this constructor is a constexpr constructor .}

🔗

template<class T, class. Args> constexpr explicit variant(in_place_type_t<T>, Args&&. args);

Effects: Direct-non-list-initializes the contained value of type T with std::forward<Args>(args)..

Remarks: If T's selected constructor is a constexpr constructor, this constructor is a constexpr constructor.

🔗

template<class T, class U, class. Args>
  constexpr explicit variant(in_place_type_t<T>, initializer_list<U> il, Args&&. args);

Effects: Direct-non-list-initializes the contained value of type T with il, std::forward<Args>(args)..

Remarks: If T's selected constructor is a constexpr constructor, this constructor is a constexpr constructor.

🔗

template<size_t I, class. Args> constexpr explicit variant(in_place_index_t<I>, Args&&. args);

Effects: Direct-non-list-initializes the contained value of type

T {I with std ​::​ forward < Args > (args) . .}_{I with std ​::​ forward < Args > (args) . .}

Remarks: If

T {I's selected constructor is a constexpr constructor, this constructor is a constexpr constructor .}_{I's selected constructor is a constexpr constructor, this constructor is a constexpr constructor .}

🔗

template<size_t I, class U, class. Args>
  constexpr explicit variant(in_place_index_t<I>, initializer_list<U> il, Args&&. args);

Effects: Direct-non-list-initializes the contained value of type

T {I with il, std ​::​ forward < Args > (​args) . .}_{I with il, std ​::​ forward < Args > (​args) . .}

Remarks: If

T {I's selected constructor is a constexpr constructor, this constructor is a constexpr constructor .}_{I's selected constructor is a constexpr constructor, this constructor is a constexpr constructor .}