20 General utilities library [utilities]

20.5 Tuples [tuple]

20.5.4 Tuple creation functions [tuple.creation]

In the function descriptions that follow, the members of a template 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<unwrap_ref_decay_t<TTypes>...> make_tuple(TTypes&&... t);

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

[Example 1:

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 objects, 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 2:

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.

Preconditions: For all i,

U_{i}

is the type

{c v}_{i}

tuple<

{Args}_{i}

...>, where

{c v}_{i}

is the (possibly empty)

i^{th}

cv-qualifier-seq and

{Args}_{i}

is the template 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 are met:

(9.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
(9.2)
is_constructible_v< $A_{i k}$ , $c v_{i} A_{i k}$ &&> == true.

Remarks: The types in CTypes are 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}

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 1:

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

— end note]