20 General utilities library [utilities]

20.5 Tuples [tuple]

20.5.3 Class template tuple [tuple.tuple]

20.5.3.1 Construction [tuple.cnstr]

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

T_{i}

be the

i^{th}

type in Types, and

U_{i}

be the

i^{th}

type in a template parameter pack named UTypes, where indexing is zero-based.

For each tuple constructor, an exception is thrown only if the construction of one of the types in Types throws an exception.

The defaulted move and copy constructor, respectively, of tuple is a constexpr function if and only if all required element-wise initializations for move and copy, respectively, would satisfy the requirements for a constexpr function.

The defaulted move and copy constructor of tuple<> are constexpr functions.

If is_trivially_destructible_v<

T_{i}

> is true for all

T_{i}

, then the destructor of tuple is trivial.

🔗

constexpr explicit(see below) tuple();

Constraints: is_default_constructible_v<

T_{i}

> is true for all i.

Effects: Value-initializes each element.

Remarks: The expression inside explicit evaluates to true if and only if

T_{i}

is not copy-list-initializable from an empty list for at least one i.

[ Note

This behavior can be implemented with a trait that checks whether a const

T_{i}

& can be initialized with {}.

— end note

]

🔗

constexpr explicit(see below) tuple(const Types&...);

Constraints:

sizeof...(Types) \geq 1

and is_copy_constructible_v<

T_{i}

> is true for all i.

Effects: Initializes each element with the value of the corresponding parameter.

Remarks: The expression inside explicit is equivalent to:

!conjunction_v<is_convertible<const Types&, Types>...>

🔗

template<class... UTypes> constexpr explicit(see below) tuple(UTypes&&... u);

Constraints: sizeof...(Types) equals sizeof...(UTypes) and

sizeof...(Types) \geq 1

and is_constructible_v<

T_{i}

U_{i}

> is true for all i.

Effects: Initializes the elements in the tuple with the corresponding value in std::forward<UTypes>(u).

Remarks: The expression inside explicit is equivalent to:

!conjunction_v<is_convertible<UTypes, Types>...>

🔗

tuple(const tuple& u) = default;

Mandates: is_copy_constructible_v<

T_{i}

> is true for all i.

Effects: Initializes each element of *this with the corresponding element of u.

🔗

tuple(tuple&& u) = default;

Constraints: is_move_constructible_v<

T_{i}

> is true for all i.

Effects: For all i, initializes the

i^{th}

element of *this with std::forward<

T_{i}

>(get(u)).

🔗

template<class... UTypes> constexpr explicit(see below) tuple(const tuple<UTypes...>& u);

Constraints:

(18.1)
sizeof...(Types) equals sizeof...(UTypes) and
(18.2)
is_constructible_v< $T_{i}$ , const $U_{i}$ &> is true for all i, and
(18.3)
either sizeof...(Types) is not 1, or (when Types... expands to T and UTypes... expands to U) is_convertible_v<const tuple&, T>, is_constructible_v<T, const tuple&>, and is_same_v<T, U> are all false.

Effects: Initializes each element of *this with the corresponding element of u.

Remarks: The expression inside explicit is equivalent to:

!conjunction_v<is_convertible<const UTypes&, Types>...>

🔗

template<class... UTypes> constexpr explicit(see below) tuple(tuple<UTypes...>&& u);

Constraints:

(21.1)
sizeof...(Types) equals sizeof...(UTypes), and
(21.2)
is_constructible_v< $T_{i}$ , $U_{i}$ > is true for all i, and
(21.3)
either sizeof...(Types) is not 1, or (when Types... expands to T and UTypes... expands to U) is_convertible_v<tuple, T>, is_constructible_v<T, tuple>, and is_same_v<T, U> are all false.

Effects: For all i, initializes the

i^{th}

element of *this with std::forward<

U_{i}

>(get(u)).

Remarks: The expression inside explicit is equivalent to:

!conjunction_v<is_convertible<UTypes, Types>...>

🔗

template<class U1, class U2> constexpr explicit(see below) tuple(const pair<U1, U2>& u);

Constraints:

(24.1)
sizeof...(Types) is 2,
(24.2)
is_constructible_v< $T_{0}$ , const U1&> is true, and
(24.3)
is_constructible_v< $T_{1}$ , const U2&> is true.

Effects: Initializes the first element with u.first and the second element with u.second.

The expression inside explicit is equivalent to:

!is_convertible_v<const U1&,  $T_{0}$ > || !is_convertible_v<const U2&,  $T_{1}$ >

🔗

template<class U1, class U2> constexpr explicit(see below) tuple(pair<U1, U2>&& u);

Constraints:

(27.1)
sizeof...(Types) is 2,
(27.2)
is_constructible_v< $T_{0}$ , U1> is true, and
(27.3)
is_constructible_v< $T_{1}$ , U2> is true.

Effects: Initializes the first element with std::forward<U1>(u.first) and the second element with std::forward<U2>(u.second).

The expression inside explicit is equivalent to:

!is_convertible_v<U1,  $T_{0}$ > || !is_convertible_v<U2,  $T_{1}$ >

🔗

template<class Alloc>
  constexpr explicit(see below)
    tuple(allocator_arg_t, const Alloc& a);
template<class Alloc>
  constexpr explicit(see below)
    tuple(allocator_arg_t, const Alloc& a, const Types&...);
template<class Alloc, class... UTypes>
  constexpr explicit(see below)
    tuple(allocator_arg_t, const Alloc& a, UTypes&&...);
template<class Alloc>
  constexpr tuple(allocator_arg_t, const Alloc& a, const tuple&);
template<class Alloc>
  constexpr tuple(allocator_arg_t, const Alloc& a, tuple&&);
template<class Alloc, class... UTypes>
  constexpr explicit(see below)
    tuple(allocator_arg_t, const Alloc& a, const tuple<UTypes...>&);
template<class Alloc, class... UTypes>
  constexpr explicit(see below)
    tuple(allocator_arg_t, const Alloc& a, tuple<UTypes...>&&);
template<class Alloc, class U1, class U2>
  constexpr explicit(see below)
    tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&);
template<class Alloc, class U1, class U2>
  constexpr explicit(see below)
    tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&);

Preconditions: Alloc meets the Cpp17Allocator requirements (Table 36).

Effects: Equivalent to the preceding constructors except that each element is constructed with uses-allocator construction .