23 General utilities library [utilities]

23.5 Tuples [tuple]

23.5.3 Class template tuple [tuple.tuple] Tuple creation functions [tuple.creation]

In the function descriptions that follow, the members of a parameter pack XTypes are denoted by X 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 be decay_­t<T> for each T in TTypes.
If U is a specialization of reference_­wrapper, then V in VTypes is U​::​type&, otherwise V is U.
Returns: tuple<VTypes...>(std​::​forward<TTypes>(t)...).
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.
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 be the type in Tuples, U be remove_­reference_­t<T>, and tp be the parameter in the function parameter pack tpls, where all indexing is zero-based.
Requires: For all i, U shall be the type tuple<Args...>, where is the (possibly empty) cv-qualifier-seq and Args is the parameter pack representing the element types in U.
Let A be the type in Args.
For all A the following requirements shall be satisfied:
  • If T is deduced as an lvalue reference type, then is_­constructible_­v<A, &> == true, otherwise
  • is_­constructible_­v<A, &&> == true.
Remarks: The types in CTypes shall be equal to the ordered sequence of the extended types Args..., Args..., , Args..., where n is equal to sizeof...(Tuples).
Let e... be the ordered sequence of tuple elements of the resulting tuple object corresponding to the type sequence Args.
Returns: A tuple object constructed by initializing the type element e in e... with
for each valid and each group e in order.
An implementation may support additional types in the parameter pack Tuples that support the tuple-like protocol, such as pair and array.
end note