23 General utilities library [utilities]

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 ]

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

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 ]

In the following paragraphs, let ${\text{T}}_i$ be the $i^{\text{th}}$ type in Tuples, ${\text{U}}_i$ be remove_­reference_­t<T${}_i$>, and ${\text{tp}}_i$ be the $i^{\text{th}}$ parameter in the function parameter pack tpls, where all indexing is zero-based.

Requires: For all i, ${\text{U}}_i$ shall be the type ${\text{cv}}_i$ tuple<${\text{Args}}_i$...>, where ${\text{cv}}_i$ is the (possibly empty) $i^{\text{th}}$ cv-qualifier-seq and ${\text{Args}}_i$ is the parameter pack representing the element types in ${\text{U}}_i$. Let ${\text{A}}_{ik}$ be the $k^{\text{th}}$ type in ${\text{Args}}_i$. For all ${\text{A}}_{ik}$ the following requirements shall be satisfied:

• (10.1)

  If ${\text{T}}_i$ is deduced as an lvalue reference type, then is_­constructible_­v<${\text{A}}_{ik}$, $c{v}_i{\text{A}}_{ik}$&> == true, otherwise

• (10.2)

  is_­constructible_­v<${\text{A}}_{ik}$, $c{v}_i{\text{A}}_{ik}$&&> == true.

Remarks: The types in CTypes shall be equal to the ordered sequence of the extended types ${\text{Args}}_0$..., ${\text{Args}}_1$..., …, ${\text{Args}}_{n-1}$..., where n is equal to sizeof...(Tuples). Let ${\text{e}}_i$... be the $i^{\text{th}}$ ordered sequence of tuple elements of the resulting tuple object corresponding to the type sequence ${\text{Args}}_i$.

Returns: A tuple object constructed by initializing the ${k_i}^{\text{th}}$ type element ${\text{e}}_{ik}$ in ${\text{e}}_i$... with

get<$k_i$>(std::forward<${\text{T}}_i$>(${\text{tp}}_i$))

for each valid $k_i$ and each group ${\text{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 ]