20 General utilities library [utilities]

Returns: tuple<unwrap_­ref_­decay_­t<TTypes>...>(std​::​forward<TTypes>(t)...).

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

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

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

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.

Preconditions: For all i, ${\text{U}}_i$ is the type ${cv}_i$ tuple<${\text{Args}}_i$...>, where ${cv}_i$ is the (possibly empty) $i^{\text{th}}$ cv-qualifier-seq and ${\text{Args}}_i$ is the template 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 are met:

• (9.1)
  If ${\text{T}}_i$ is deduced as an lvalue reference type, then is_­constructible_­v<${\text{A}}_{ik}$, $cv{}_i{\text{A}}_{ik}$&> == true, otherwise
• (9.2)
  is_­constructible_­v<${\text{A}}_{ik}$, $cv{}_i{\text{A}}_{ik}$&&> == true.

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

Effects: Given the exposition-only function: template<class F, class Tuple, size_t... I> constexpr decltype(auto) apply-impl(F&& f, Tuple&& t, index_sequence<I...>) { // exposition only return INVOKE(std::forward<F>(f), std::get<I>(std::forward<Tuple>(t))...); // see [func.require] }

Equivalent to: return apply-impl(std::forward<F>(f), std::forward<Tuple>(t), make_index_sequence<tuple_size_v<remove_reference_t<Tuple>>>{});

Effects: Given the exposition-only function: template<class T, class Tuple, size_t... I> constexpr T make-from-tuple-impl(Tuple&& t, index_sequence<I...>) { // exposition only return T(get<I>(std::forward<Tuple>(t))...); }

Equivalent to: return make-from-tuple-impl<T>( forward<Tuple>(t), make_index_sequence<tuple_size_v<remove_reference_t<Tuple>>>{});

All specializations of tuple_­size meet the Cpp17UnaryTypeTrait requirements ([meta.rqmts]) with a base characteristic of integral_­constant<size_­t, N> for some N.

Mandates: $\text{I}<\text{sizeof...(Types)}$.

Type: TI is the type of the ${\text{I}}^{\text{th}}$ element of Types, where indexing is zero-based.

Let TS denote tuple_­size<T> of the cv-unqualified type T.

If the expression TS​::​value is well-formed when treated as an unevaluated operand, then each specialization of the template meets the Cpp17UnaryTypeTrait requirements ([meta.rqmts]) with a base characteristic of integral_constant<size_t, TS::value>

Otherwise, it has no member value.

Access checking is performed as if in a context unrelated to TS and T.

Only the validity of the immediate context of the expression is considered.

In addition to being available via inclusion of the <tuple> header, the template is available when any of the headers <array>, <ranges>, or <utility> are included.

Let TE denote tuple_­element_­t<I, T> of the cv-unqualified type T.

Then each specialization of the template meets the Cpp17TransformationTrait requirements ([meta.rqmts]) with a member typedef type that names the type add_­const_­t<TE>.

In addition to being available via inclusion of the <tuple> header, the template is available when any of the headers <array>, <ranges>, or <utility> are included.

Mandates: $\text{I}<\text{sizeof...(Types)}$.

Returns: A reference to the ${\text{I}}^{\text{th}}$ element of t, where indexing is zero-based.

Mandates: The type T occurs exactly once in Types.

Returns: A reference to the element of t corresponding to the type T in Types.

Mandates: For all i, where $0\le \text{i}<\text{sizeof...(TTypes)}$, get<i>(t) == get<i>(u) is a valid expression returning a type that is convertible to bool.

sizeof...(TTypes) equals sizeof...(UTypes).

Returns: true if get<i>(t) == get<i>(u) for all i, otherwise false.

For any two zero-length tuples e and f, e == f returns true.

Remarks: The elementary comparisons are performed in order from the zeroth index upwards.

No comparisons or element accesses are performed after the first equality comparison that evaluates to false.

Effects: Performs a lexicographical comparison between t and u.

For any two zero-length tuples t and u, t <=> u returns strong_­ordering​::​equal.

Otherwise, equivalent to: if (auto c = synth-three-way(get<0>(t), get<0>(u)); c != 0) return c; return ${\text{t}}_{tail}$ <=> ${\text{u}}_{tail}$; where ${\text{r}}_{tail}$ for some tuple r is a tuple containing all but the first element of r.

Preconditions: Alloc meets the Cpp17Allocator requirements (Table 36).

Constraints: is_­swappable_­v<T> is true for every type T in Types.

Effects: As if by x.swap(y).

Remarks: The expression inside noexcept is equivalent to: noexcept(x.swap(y))