22 General utilities library [utilities]

22.6 Variants [variant]

22.6.3 Class template variant [variant.variant]

22.6.3.2 Constructors [variant.ctor]

In the descriptions that follow, let i be in the range [0, sizeof...(Types)), and

T_{i}

be the

i^{th}

type in Types.

🔗

constexpr variant() noexcept(see below);

Constraints: is_default_constructible_v<

T_{0}

> is true.

Effects: Constructs a variant holding a value-initialized value of type

T_{0}

Postconditions: valueless_by_exception() is false and index() is 0.

Throws: Any exception thrown by the value-initialization of

T_{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]).

The exception specification is equivalent to is_nothrow_default_constructible_v<

T_{0}

[Note 1:

See also class monostate.

— end note]

🔗

constexpr variant(const variant& w);

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.

Throws: Any exception thrown by direct-initializing any

T_{i}

for all i.

Remarks: This constructor is defined as deleted unless is_copy_constructible_v<

T_{i}

> is true for all i.

If is_trivially_copy_constructible_v<

T_{i}

> is true for all i, this constructor is trivial.

🔗

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

Constraints: is_move_constructible_v<

T_{i}

> is true for all i.

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.

Throws: Any exception thrown by move-constructing any

T_{i}

for all i.

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

T_{i}

> for all i.

If is_trivially_move_constructible_v<

T_{i}

> is true for all i, this constructor is trivial.

🔗

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.

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.

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
(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).

Postconditions: holds_alternative<

T_{j}

>(*this) is true.

Throws: Any exception thrown by the initialization of the selected alternative

T_{j}

Remarks: The exception specification is equivalent to is_nothrow_constructible_v<

T_{j}

, T>.

T_{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);

Constraints:

(20.1)
There is exactly one occurrence of T in Types... and
(20.2)
is_constructible_v<T, Args...> is true.

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

Postconditions: holds_alternative<T>(*this) is true.

Throws: Any exception thrown by calling the selected constructor of T.

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

Constraints:

(25.1)
There is exactly one occurrence of T in Types... and
(25.2)
is_constructible_v<T, initializer_list<U>&, Args...> is true.

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

Postconditions: holds_alternative<T>(*this) is true.

Throws: Any exception thrown by calling the selected constructor of T.

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

Constraints:

(30.1)
I is less than sizeof...(Types) and
(30.2)
is_constructible_v< $T_{I}$ , Args...> is true.

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

T_{I}

with std::forward<Args>(args)....

Postconditions: index() is I.

Throws: Any exception thrown by calling the selected constructor of

T_{I}

Remarks: If

T_{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);

Constraints:

(35.1)
I is less than sizeof...(Types) and
(35.2)
is_constructible_v< $T_{I}$ , initializer_list<U>&, Args...> is true.

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

T_{I}

with il, std::forward<Args>(args)....

Postconditions: index() is I.

Remarks: If

T_{I}

's selected constructor is a constexpr constructor, this constructor is a constexpr constructor.