23 General utilities library [utilities]

23.5 Tuples [tuple]

23.5.3 Class template tuple [tuple.tuple]

23.5.3.4 Tuple creation functions [tuple.creation]

In the function descriptions that follow, the members of a parameter pack XTypes are denoted by X

_{i}

for i in [0, sizeof...(XTypes)) in order, where indexing is zero-based.

🔗

template<class... TTypes>
  constexpr tuple<VTypes...> make_tuple(TTypes&&... t);

The pack VTypes is defined as follows.

Let U

_{i}

be decay_t<T

_{i}

> for each T

_{i}

in TTypes.

If U

_{i}

is a specialization of reference_wrapper, then V

_{i}

in VTypes is U

_{i}

::type&, otherwise V

_{i}

is U

_{i}

Returns: tuple<VTypes...>(std::forward<TTypes>(t)...).

[ Example

int i; float j;
make_tuple(1, ref(i), cref(j))

creates a tuple of type tuple<int, int&, const float&>.

— end example

]

🔗

template<class... TTypes>
  constexpr tuple<TTypes&&...> forward_as_tuple(TTypes&&... t) noexcept;

Effects: Constructs a tuple of references to the arguments in t suitable for forwarding as arguments to a function.

Because the result may contain references to temporary variables, a program shall ensure that the return value of this function does not outlive any of its arguments (e.g., the program should typically not store the result in a named variable).

Returns: tuple<TTypes&&...>(std::forward<TTypes>(t)...).

🔗

template<class... TTypes>
  constexpr tuple<TTypes&...> tie(TTypes&... t) noexcept;

Returns: tuple<TTypes&...>(t...).

When an argument in t is ignore, assigning any value to the corresponding tuple element has no effect.

[ Example

tie functions allow one to create tuples that unpack tuples into variables.

ignore can be used for elements that are not needed:

int i; std::string s;
tie(i, ignore, s) = make_tuple(42, 3.14, "C++");
// i == 42, s == "C++"

— end example

]

🔗

template <class... Tuples>
  constexpr tuple<CTypes...> tuple_cat(Tuples&&... tpls);

In the following paragraphs, let T

_{i}

be the

i^{th}

type in Tuples, U

_{i}

be remove_reference_t<T

_{i}

>, and tp

_{i}

be the

i^{th}

parameter in the function parameter pack tpls, where all indexing is zero-based.

Requires: For all i, U

_{i}

shall be the type

{cv}_{i}

tuple<Args

_{i}

...>, where

{cv}_{i}

is the (possibly empty)

i^{th}

cv-qualifier-seq and Args

_{i}

is the parameter pack representing the element types in U

_{i}

Let A

_{i k}

be the

k^{th}

type in Args

_{i}

For all A

_{i k}

the following requirements shall be satisfied:

(10.1)
If T $_{i}$ is deduced as an lvalue reference type, then is_constructible_v<A $_{i k}$ , $c v_{i} A_{i k}$ &> == true, otherwise
(10.2)
is_constructible_v<A $_{i k}$ , $c v_{i} A_{i k}$ &&> == true.

Remarks: The types in CTypes shall be equal to the ordered sequence of the extended types Args

_{0}

..., Args

_{1}

..., …, Args

_{n - 1}

..., where n is equal to sizeof...(Tuples).

Let e

_{i}

... be the

i^{th}

ordered sequence of tuple elements of the resulting tuple object corresponding to the type sequence Args

_{i}

Returns: A tuple object constructed by initializing the

{k_{i}}^{th}

type element e

_{i k}

in e

_{i}

... with

get< $k_{i}$ >(std::forward<T $_{i}$ >(tp $_{i}$ ))

for each valid

k_{i}

and each group e

_{i}

in order.

[ Note

An implementation may support additional types in the parameter pack Tuples that support the tuple-like protocol, such as pair and array.

— end note

]