22 General utilities library [utilities]

22.4 Tuples [tuple]

22.4.5 Tuple creation functions [tuple.creation]

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<tuple-like... Tuples>
  constexpr tuple<CTypes...> tuple_cat(Tuples&&... tpls);

Let n be sizeof...(Tuples).

For every integer

0 \leq i < n

(7.1)
Let $T_{i}$ be the $i^{th}$ type in Tuples.
(7.2)
Let $U_{i}$ be remove_cvref_t< $T_{i}$ >.
(7.3)
Let ${tp}_{i}$ be the $i^{th}$ element in the function parameter pack tpls.
(7.4)
Let $S_{i}$ be tuple_size_v< $U_{i}$ >.
(7.5)
Let $E_{i}^{k}$ be tuple_element_t<k, $U_{i}$ >.
(7.6)
Let $e_{i}^{k}$ be get<k>(std::forward< $T_{i}$ >( ${tp}_{i}$ )).
(7.7)
Let $E l e m s_{i}$ be a pack of the types $E_{i}^{0}, \dots, E_{i}^{S_{i - 1}}$ .
(7.8)
Let $e l e m s_{i}$ be a pack of the expressions $e_{i}^{0}, \dots, e_{i}^{S_{i - 1}}$ .

The types in CTypes are equal to the ordered sequence of the expanded packs of types

E l e m s_{0}

...,

E l e m s_{1}

..., …,

E l e m s_{n - 1}

....

Let celems be the ordered sequence of the expanded packs of expressions

e l e m s_{0}

..., …,

e l e m s_{n - 1}

....

Mandates: (is_constructible_v<CTypes, decltype(celems)> && ...) is true.

Returns: tuple<CTypes...>(celems...).