22 General utilities library [utilities]

A type T models and satisfies the exposition-only concept tuple-like if remove_cvref_t<T> is a specialization of array, complex, pair, tuple, or ranges​::​subrange.

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.

Let n be sizeof...(Tuples).

For every integer $0\le i<n$:

• (7.1)
  Let ${\text{T}}_i$ be the $i^{\text{th}}$ type in Tuples.
• (7.2)
  Let ${\text{U}}_i$ be remove_cvref_t<${\text{T}}_i$>.
• (7.3)
  Let ${\text{tp}}_i$ be the $i^{\text{th}}$ element in the function parameter pack tpls.
• (7.4)
  Let $S_i$ be tuple_size_v<${\text{U}}_i$>.
• (7.5)
  Let $E_i^k$ be tuple_element_t<k, ${\text{U}}_i$>.
• (7.6)
  Let $e_i^k$ be get<k>(std​::​forward<${\text{T}}_i$>(${\text{tp}}_i$)).
• (7.7)
  Let $Elem{s}_i$ be a pack of the types $E_i^0,\dots ,E_i^{S_{i-1}}$.
• (7.8)
  Let $elem{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 $Elem{s}_0$..., $Elem{s}_1$..., …, $Elem{s}_{n-1}$....

Let celems be the ordered sequence of the expanded packs of expressions $elem{s}_0$..., …, $elem{s}_{n-1}$....

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

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

Effects: Given the exposition-only function template: namespace std { template<class F, tuple-like Tuple, size_t... I> constexpr decltype(auto) apply-impl(F&& f, Tuple&& t, index_sequence<I...>) { // exposition only return INVOKE(std::forward<F>(f), 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>>>{});

Remarks: Let I be the pack 0, 1, ..., (tuple_size_v<remove_reference_t<Tuple>> - 1).

The exception specification is equivalent to: noexcept(invoke(std::forward<F>(f), get<I>(std::forward<Tuple>(t))...))

Mandates: If tuple_size_v<remove_reference_t<Tuple>> is 1, then reference_constructs_from_temporary_v<T, decltype(get<0>(declval<Tuple>()))> is false.

Effects: Given the exposition-only function template: namespace std { template<class T, tuple-like Tuple, size_t... I> requires is_constructible_v<T, decltype(get<I>(declval<Tuple>()))...> 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>( std::forward<Tuple>(t), make_index_sequence<tuple_size_v<remove_reference_t<Tuple>>>{});

Except where specified otherwise, 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: I < 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: I < 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.

For the first overload let UTuple be tuple<UTypes...>.

Mandates: For all i, where 0  ≤ i < sizeof...(TTypes), get<i>(t) == get<i>(u) is a valid expression.

sizeof...(TTypes) equals tuple_size_v<UTuple>.

Preconditions: For all i, decltype(get<i>(t) == get<i>(u)) models boolean-testable.

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

Remarks:

• (5.1)
  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.
• (5.2)
  The second overload is to be found via argument-dependent lookup ([basic.lookup.argdep]) only.

For the second overload, Elems denotes the pack of types tuple_element_t<0, UTuple>, tuple_element_t<1, UTuple>, …, tuple_element_t<tuple_size_v<UTuple> - 1, UTuple>.

Effects: Performs a lexicographical comparison between t and u.

If sizeof...(TTypes) equals zero, 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 r is a tuple containing all but the first element of r.

Remarks: The second overload is to be found via argument-dependent lookup ([basic.lookup.argdep]) only.

Constraints:

• (2.1)
  TTuple is a specialization of tuple or UTuple is a specialization of tuple.
• (2.2)
  is_same_v<TTuple, decay_t<TTuple>> is true.
• (2.3)
  is_same_v<UTuple, decay_t<UTuple>> is true.
• (2.4)
  tuple_size_v<TTuple> equals tuple_size_v<UTuple>.
• (2.5)
  tuple<common_reference_t<TQual<TTypes>, UQual<UTypes>>...> denotes a type.