20 General utilities library [utilities]

20.5 Tuples [tuple]

20.5.1 In general [tuple.general]

Subclause [tuple] describes the tuple library that provides a tuple type as the class template tuple that can be instantiated with any number of arguments.

Each template argument specifies the type of an element in the tuple.

Consequently, tuples are heterogeneous, fixed-size collections of values.

An instantiation of tuple with two arguments is similar to an instantiation of pair with the same two arguments.

See [pairs].

20.5.2 Header <tuple> synopsis [tuple.syn]

#include <compare>              // see [compare.syn]

namespace std {
  // [tuple.tuple], class template tuple
  template<class... Types>
    class tuple;

  // [tuple.creation], tuple creation functions
  inline constexpr unspecified ignore;

  template<class... TTypes>
    constexpr tuple<unwrap_ref_decay_t<TTypes>...> make_tuple(TTypes&&...);

  template<class... TTypes>
    constexpr tuple<TTypes&&...> forward_as_tuple(TTypes&&...) noexcept;

  template<class... TTypes>
    constexpr tuple<TTypes&...> tie(TTypes&...) noexcept;

  template<class... Tuples>
    constexpr tuple<CTypes...> tuple_cat(Tuples&&...);

  // [tuple.apply], calling a function with a tuple of arguments
  template<class F, class Tuple>
    constexpr decltype(auto) apply(F&& f, Tuple&& t);

  template<class T, class Tuple>
    constexpr T make_from_tuple(Tuple&& t);

  // [tuple.helper], tuple helper classes
  template<class T> struct tuple_size;                  // not defined
  template<class T> struct tuple_size<const T>;

  template<class... Types> struct tuple_size<tuple<Types...>>;

  template<size_t I, class T> struct tuple_element;     // not defined
  template<size_t I, class T> struct tuple_element<I, const T>;

  template<size_t I, class... Types>
    struct tuple_element<I, tuple<Types...>>;

  template<size_t I, class T>
    using tuple_element_t = typename tuple_element<I, T>::type;

  // [tuple.elem], element access
  template<size_t I, class... Types>
    constexpr tuple_element_t<I, tuple<Types...>>& get(tuple<Types...>&) noexcept;
  template<size_t I, class... Types>
    constexpr tuple_element_t<I, tuple<Types...>>&& get(tuple<Types...>&&) noexcept;
  template<size_t I, class... Types>
    constexpr const tuple_element_t<I, tuple<Types...>>& get(const tuple<Types...>&) noexcept;
  template<size_t I, class... Types>
    constexpr const tuple_element_t<I, tuple<Types...>>&& get(const tuple<Types...>&&) noexcept;
  template<class T, class... Types>
    constexpr T& get(tuple<Types...>& t) noexcept;
  template<class T, class... Types>
    constexpr T&& get(tuple<Types...>&& t) noexcept;
  template<class T, class... Types>
    constexpr const T& get(const tuple<Types...>& t) noexcept;
  template<class T, class... Types>
    constexpr const T&& get(const tuple<Types...>&& t) noexcept;

  // [tuple.rel], relational operators
  template<class... TTypes, class... UTypes>
    constexpr bool operator==(const tuple<TTypes...>&, const tuple<UTypes...>&);
  template<class... TTypes, class... UTypes>
    constexpr common_comparison_category_t<synth-three-way-result<TTypes, UTypes>...>
      operator<=>(const tuple<TTypes...>&, const tuple<UTypes...>&);

  // [tuple.traits], allocator-related traits
  template<class... Types, class Alloc>
    struct uses_allocator<tuple<Types...>, Alloc>;

  // [tuple.special], specialized algorithms
  template<class... Types>
    constexpr void swap(tuple<Types...>& x, tuple<Types...>& y) noexcept(see below);

  // [tuple.helper], tuple helper classes
  template<class T>
    inline constexpr size_t tuple_size_v = tuple_size<T>::value;
}

20.5.3 Class template tuple [tuple.tuple]

namespace std {
  template<class... Types>
  class tuple {
  public:
    // [tuple.cnstr], tuple construction
    constexpr explicit(see below) tuple();
    constexpr explicit(see below) tuple(const Types&...);         // only if sizeof...(Types) >= 1
    template<class... UTypes>
      constexpr explicit(see below) tuple(UTypes&&...);           // only if sizeof...(Types) >= 1

    tuple(const tuple&) = default;
    tuple(tuple&&) = default;

    template<class... UTypes>
      constexpr explicit(see below) tuple(const tuple<UTypes...>&);
    template<class... UTypes>
      constexpr explicit(see below) tuple(tuple<UTypes...>&&);

    template<class U1, class U2>
      constexpr explicit(see below) tuple(const pair<U1, U2>&);   // only if sizeof...(Types) == 2
    template<class U1, class U2>
      constexpr explicit(see below) tuple(pair<U1, U2>&&);        // only if sizeof...(Types) == 2

    // allocator-extended constructors
    template<class Alloc>
      constexpr explicit(see below)
        tuple(allocator_arg_t, const Alloc& a);
    template<class Alloc>
      constexpr explicit(see below)
        tuple(allocator_arg_t, const Alloc& a, const Types&...);
    template<class Alloc, class... UTypes>
      constexpr explicit(see below)
        tuple(allocator_arg_t, const Alloc& a, UTypes&&...);
    template<class Alloc>
      constexpr tuple(allocator_arg_t, const Alloc& a, const tuple&);
    template<class Alloc>
      constexpr tuple(allocator_arg_t, const Alloc& a, tuple&&);
    template<class Alloc, class... UTypes>
      constexpr explicit(see below)
        tuple(allocator_arg_t, const Alloc& a, const tuple<UTypes...>&);
    template<class Alloc, class... UTypes>
      constexpr explicit(see below)
        tuple(allocator_arg_t, const Alloc& a, tuple<UTypes...>&&);
    template<class Alloc, class U1, class U2>
      constexpr explicit(see below)
        tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&);
    template<class Alloc, class U1, class U2>
      constexpr explicit(see below)
        tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&);

    // [tuple.assign], tuple assignment
    constexpr tuple& operator=(const tuple&);
    constexpr tuple& operator=(tuple&&) noexcept(see below);

    template<class... UTypes>
      constexpr tuple& operator=(const tuple<UTypes...>&);
    template<class... UTypes>
      constexpr tuple& operator=(tuple<UTypes...>&&);

    template<class U1, class U2>
      constexpr tuple& operator=(const pair<U1, U2>&);          // only if sizeof...(Types) == 2
    template<class U1, class U2>
      constexpr tuple& operator=(pair<U1, U2>&&);               // only if sizeof...(Types) == 2

    // [tuple.swap], tuple swap
    constexpr void swap(tuple&) noexcept(see below);
  };

  template<class... UTypes>
    tuple(UTypes...) -> tuple<UTypes...>;
  template<class T1, class T2>
    tuple(pair<T1, T2>) -> tuple<T1, T2>;
  template<class Alloc, class... UTypes>
    tuple(allocator_arg_t, Alloc, UTypes...) -> tuple<UTypes...>;
  template<class Alloc, class T1, class T2>
    tuple(allocator_arg_t, Alloc, pair<T1, T2>) -> tuple<T1, T2>;
  template<class Alloc, class... UTypes>
    tuple(allocator_arg_t, Alloc, tuple<UTypes...>) -> tuple<UTypes...>;
}

20.5.3.1 Construction [tuple.cnstr]

In the descriptions that follow, let i be in the range [0, sizeof...(Types)) in order,

T_{i}

be the

i^{th}

type in Types, and

U_{i}

be the

i^{th}

type in a template parameter pack named UTypes, where indexing is zero-based.

For each tuple constructor, an exception is thrown only if the construction of one of the types in Types throws an exception.

The defaulted move and copy constructor, respectively, of tuple is a constexpr function if and only if all required element-wise initializations for move and copy, respectively, would satisfy the requirements for a constexpr function.

The defaulted move and copy constructor of tuple<> are constexpr functions.

If is_trivially_destructible_v<

T_{i}

> is true for all

T_{i}

, then the destructor of tuple is trivial.

🔗

constexpr explicit(see below) tuple();

Constraints: is_default_constructible_v<

T_{i}

> is true for all i.

Effects: Value-initializes each element.

Remarks: The expression inside explicit evaluates to true if and only if

T_{i}

is not copy-list-initializable from an empty list for at least one i.

[Note

This behavior can be implemented with a trait that checks whether a const

T_{i}

& can be initialized with {}.

— end note

]

🔗

constexpr explicit(see below) tuple(const Types&...);

Constraints:

sizeof...(Types) \geq 1

and is_copy_constructible_v<

T_{i}

> is true for all i.

Effects: Initializes each element with the value of the corresponding parameter.

Remarks: The expression inside explicit is equivalent to:

!conjunction_v<is_convertible<const Types&, Types>...>

🔗

template<class... UTypes> constexpr explicit(see below) tuple(UTypes&&... u);

Constraints: sizeof...(Types) equals sizeof...(UTypes) and

sizeof...(Types) \geq 1

and is_constructible_v<

T_{i}

U_{i}

> is true for all i.

Effects: Initializes the elements in the tuple with the corresponding value in std::forward<UTypes>(u).

Remarks: The expression inside explicit is equivalent to:

!conjunction_v<is_convertible<UTypes, Types>...>

🔗

tuple(const tuple& u) = default;

Mandates: is_copy_constructible_v<

T_{i}

> is true for all i.

Effects: Initializes each element of *this with the corresponding element of u.

🔗

tuple(tuple&& u) = default;

Constraints: is_move_constructible_v<

T_{i}

> is true for all i.

Effects: For all i, initializes the

i^{th}

element of *this with std::forward<

T_{i}

>(get(u)).

🔗

template<class... UTypes> constexpr explicit(see below) tuple(const tuple<UTypes...>& u);

Constraints:

(18.1)
sizeof...(Types) equals sizeof...(UTypes) and
(18.2)
is_constructible_v< $T_{i}$ , const $U_{i}$ &> is true for all i, and
(18.3)
either sizeof...(Types) is not 1, or (when Types... expands to T and UTypes... expands to U) is_convertible_v<const tuple&, T>, is_constructible_v<T, const tuple&>, and is_same_v<T, U> are all false.

Effects: Initializes each element of *this with the corresponding element of u.

Remarks: The expression inside explicit is equivalent to:

!conjunction_v<is_convertible<const UTypes&, Types>...>

🔗

template<class... UTypes> constexpr explicit(see below) tuple(tuple<UTypes...>&& u);

Constraints:

(21.1)
sizeof...(Types) equals sizeof...(UTypes), and
(21.2)
is_constructible_v< $T_{i}$ , $U_{i}$ > is true for all i, and
(21.3)
either sizeof...(Types) is not 1, or (when Types... expands to T and UTypes... expands to U) is_convertible_v<tuple, T>, is_constructible_v<T, tuple>, and is_same_v<T, U> are all false.

Effects: For all i, initializes the

i^{th}

element of *this with std::forward<

U_{i}

>(get(u)).

Remarks: The expression inside explicit is equivalent to:

!conjunction_v<is_convertible<UTypes, Types>...>

🔗

template<class U1, class U2> constexpr explicit(see below) tuple(const pair<U1, U2>& u);

Constraints:

(24.1)
sizeof...(Types) is 2,
(24.2)
is_constructible_v< $T_{0}$ , const U1&> is true, and
(24.3)
is_constructible_v< $T_{1}$ , const U2&> is true.

Effects: Initializes the first element with u.first and the second element with u.second.

The expression inside explicit is equivalent to:

!is_convertible_v<const U1&,  $T_{0}$ > || !is_convertible_v<const U2&,  $T_{1}$ >

🔗

template<class U1, class U2> constexpr explicit(see below) tuple(pair<U1, U2>&& u);

Constraints:

(27.1)
sizeof...(Types) is 2,
(27.2)
is_constructible_v< $T_{0}$ , U1> is true, and
(27.3)
is_constructible_v< $T_{1}$ , U2> is true.

Effects: Initializes the first element with std::forward<U1>(u.first) and the second element with std::forward<U2>(u.second).

The expression inside explicit is equivalent to:

!is_convertible_v<U1,  $T_{0}$ > || !is_convertible_v<U2,  $T_{1}$ >

🔗

template<class Alloc>
  constexpr explicit(see below)
    tuple(allocator_arg_t, const Alloc& a);
template<class Alloc>
  constexpr explicit(see below)
    tuple(allocator_arg_t, const Alloc& a, const Types&...);
template<class Alloc, class... UTypes>
  constexpr explicit(see below)
    tuple(allocator_arg_t, const Alloc& a, UTypes&&...);
template<class Alloc>
  constexpr tuple(allocator_arg_t, const Alloc& a, const tuple&);
template<class Alloc>
  constexpr tuple(allocator_arg_t, const Alloc& a, tuple&&);
template<class Alloc, class... UTypes>
  constexpr explicit(see below)
    tuple(allocator_arg_t, const Alloc& a, const tuple<UTypes...>&);
template<class Alloc, class... UTypes>
  constexpr explicit(see below)
    tuple(allocator_arg_t, const Alloc& a, tuple<UTypes...>&&);
template<class Alloc, class U1, class U2>
  constexpr explicit(see below)
    tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&);
template<class Alloc, class U1, class U2>
  constexpr explicit(see below)
    tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&);

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

Effects: Equivalent to the preceding constructors except that each element is constructed with uses-allocator construction .

20.5.3.2 Assignment [tuple.assign]

For each tuple assignment operator, an exception is thrown only if the assignment of one of the types in Types throws an exception.

In the function descriptions that follow, let i be in the range [0, sizeof...(Types)) in order,

T_{i}

be the

i^{th}

type in Types, and

U_{i}

be the

i^{th}

type in a template parameter pack named UTypes, where indexing is zero-based.

🔗

constexpr tuple& operator=(const tuple& u);

Effects: Assigns each element of u to the corresponding element of *this.

Remarks: This operator is defined as deleted unless is_copy_assignable_v<

T_{i}

> is true for all i.

Returns: *this.

🔗

constexpr tuple& operator=(tuple&& u) noexcept(see below);

Constraints: is_move_assignable_v<

T_{i}

> is true for all i.

Effects: For all i, assigns std::forward<

T_{i}

>(get(u)) to get(*this).

Remarks: The expression inside noexcept is equivalent to the logical and of the following expressions:

is_nothrow_move_assignable_v< $T_{i}$ >

where

T_{i}

is the

i^{th}

type in Types.

Returns: *this.

🔗

template<class... UTypes> constexpr tuple& operator=(const tuple<UTypes...>& u);

Constraints:

(9.1)
sizeof...(Types) equals sizeof...(UTypes) and
(9.2)
is_assignable_v< $T_{i}$ &, const $U_{i}$ &> is true for all i.

Effects: Assigns each element of u to the corresponding element of *this.

Returns: *this.

🔗

template<class... UTypes> constexpr tuple& operator=(tuple<UTypes...>&& u);

Constraints:

(12.1)
sizeof...(Types) equals sizeof...(UTypes) and
(12.2)
is_assignable_v< $T_{i}$ &, $U_{i}$ > is true for all i.

Effects: For all i, assigns std::forward<

U_{i}

>(get(u)) to get(*this).

Returns: *this.

🔗

template<class U1, class U2> constexpr tuple& operator=(const pair<U1, U2>& u);

Constraints:

(15.1)
sizeof...(Types) is 2 and
(15.2)
is_assignable_v< $T_{0}$ &, const U1&> is true, and
(15.3)
is_assignable_v< $T_{1}$ &, const U2&> is true.

Effects: Assigns u.first to the first element of *this and u.second to the second element of *this.

Returns: *this.

🔗

template<class U1, class U2> constexpr tuple& operator=(pair<U1, U2>&& u);

Constraints:

(18.1)
sizeof...(Types) is 2 and
(18.2)
is_assignable_v< $T_{0}$ &, U1> is true, and
(18.3)
is_assignable_v< $T_{1}$ &, U2> is true.

Effects: Assigns std::forward<U1>(u.first) to the first element of *this and

std::forward<U2>(u.second) to the second element of *this.

Returns: *this.

20.5.3.3 swap [tuple.swap]

🔗

constexpr void swap(tuple& rhs) noexcept(see below);

Preconditions: Each element in *this is swappable with ([swappable.requirements]) the corresponding element in rhs.

Effects: Calls swap for each element in *this and its corresponding element in rhs.

Remarks: The expression inside noexcept is equivalent to the logical and of the following expressions:

is_nothrow_swappable_v< $T_{i}$ >

where

T_{i}

is the

i^{th}

type in Types.

Throws: Nothing unless one of the element-wise swap calls throws an exception.

20.5.4 Tuple creation functions [tuple.creation]

In the function descriptions that follow, the members of a template parameter pack XTypes are denoted by X

_{i}

for i in [0, sizeof...(XTypes)) in order, where indexing is zero-based.

🔗

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

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

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_{i}

be the

i^{th}

type in Tuples,

U_{i}

be remove_reference_t<T

_{i}

>, and

{tp}_{i}

be the

i^{th}

parameter in the function parameter pack tpls, where all indexing is zero-based.

Preconditions: For all i,

U_{i}

is the type

{c v}_{i}

tuple<

{Args}_{i}

...>, where

{c v}_{i}

is the (possibly empty)

i^{th}

cv-qualifier-seq and

{Args}_{i}

is the template parameter pack representing the element types in

U_{i}

Let

A_{i k}

be the

k^{th}

type in

{Args}_{i}

For all

A_{i k}

the following requirements are met:

(9.1)
If $T_{i}$ is deduced as an lvalue reference type, then is_constructible_v< $A_{i k}$ , $c v_{i} A_{i k}$ &> == true, otherwise
(9.2)
is_constructible_v< $A_{i k}$ , $c v_{i} A_{i k}$ &&> == true.

Remarks: The types in CTypes are equal to the ordered sequence of the extended types

{Args}_{0}

...,

{Args}_{1}

..., …,

{Args}_{n - 1}

..., where n is equal to sizeof...(Tuples).

Let

e_{i}

... be the

i^{th}

ordered sequence of tuple elements of the resulting tuple object corresponding to the type sequence

{Args}_{i}

Returns: A tuple object constructed by initializing the

{k_{i}}^{th}

type element

e_{i k}

e_{i}

... with

get< $k_{i}$ >(std::forward< $T_{i}$ >( ${tp}_{i}$ ))

for each valid

k_{i}

and each group

e_{i}

in order.

[Note

An implementation may support additional types in the template parameter pack Tuples that support the tuple-like protocol, such as pair and array.

— end note

]

20.5.5 Calling a function with a tuple of arguments [tuple.apply]

🔗

template<class F, class Tuple>
  constexpr decltype(auto) apply(F&& f, Tuple&& t);

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>>>{});

🔗

template<class T, class Tuple>
  constexpr T make_from_tuple(Tuple&& t);

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>>>{});

[Note

: The type of T must be supplied as an explicit template parameter, as it cannot be deduced from the argument list. — end note

]

20.5.6 Tuple helper classes [tuple.helper]

🔗

template<class T> struct tuple_size;

All specializations of tuple_size meet the Cpp17UnaryTypeTrait requirements ([meta.rqmts]) with a base characteristic of integral_constant<size_t, N> for some N.

🔗

template<class... Types>
  struct tuple_size<tuple<Types...>> : public integral_constant<size_t, sizeof...(Types)> { };

🔗

template<size_t I, class... Types>
  struct tuple_element<I, tuple<Types...>> {
    using type = TI;
  };

Mandates:

I < sizeof...(Types)

Type: TI is the type of the

I^{th}

element of Types, where indexing is zero-based.

🔗

template<class T> struct tuple_size<const T>;

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.

[Note

The compilation of the expression can result in side effects such as the instantiation of class template specializations and function template specializations, the generation of implicitly-defined functions, and so on.

Such side effects are not in the “immediate context” and can result in the program being ill-formed.

— end note

]

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

🔗

template<size_t I, class T> struct tuple_element<I, const T>;

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

20.5.7 Element access [tuple.elem]

🔗

template<size_t I, class... Types>
  constexpr tuple_element_t<I, tuple<Types...>>&
    get(tuple<Types...>& t) noexcept;
template<size_t I, class... Types>
  constexpr tuple_element_t<I, tuple<Types...>>&&
    get(tuple<Types...>&& t) noexcept;        // Note A
template<size_t I, class... Types>
  constexpr const tuple_element_t<I, tuple<Types...>>&
    get(const tuple<Types...>& t) noexcept;   // Note B
template<size_t I, class... Types>
  constexpr const tuple_element_t<I, tuple<Types...>>&& get(const tuple<Types...>&& t) noexcept;

Mandates:

I < sizeof...(Types)

Returns: A reference to the

I^{th}

element of t, where indexing is zero-based.

[Note A

If a type T in Types is some reference type X&, the return type is X&, not X&&.

However, if the element type is a non-reference type T, the return type is T&&.

— end note

]

[Note B

Constness is shallow.

If a type T in Types is some reference type X&, the return type is X&, not const X&.

However, if the element type is a non-reference type T, the return type is const T&.

This is consistent with how constness is defined to work for member variables of reference type.

— end note

]

🔗

template<class T, class... Types>
  constexpr T& get(tuple<Types...>& t) noexcept;
template<class T, class... Types>
  constexpr T&& get(tuple<Types...>&& t) noexcept;
template<class T, class... Types>
  constexpr const T& get(const tuple<Types...>& t) noexcept;
template<class T, class... Types>
  constexpr const T&& get(const tuple<Types...>&& t) noexcept;

Mandates: The type T occurs exactly once in Types.

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

[Example

const tuple<int, const int, double, double> t(1, 2, 3.4, 5.6);
const int& i1 = get<int>(t);                    // OK, i1 has value 1
const int& i2 = get<const int>(t);              // OK, i2 has value 2
const double& d = get<double>(t);               // error: type double is not unique within t

— end example

]

[Note

The reason get is a non-member function is that if this functionality had been provided as a member function, code where the type depended on a template parameter would have required using the template keyword.

— end note

]

20.5.8 Relational operators [tuple.rel]

🔗

template<class... TTypes, class... UTypes>
  constexpr bool operator==(const tuple<TTypes...>& t, const tuple<UTypes...>& u);

Mandates: For all i, where

0 \leq i < sizeof...(TTypes)

, get(t) == get(u) is a valid expression returning a type that is convertible to bool.

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

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

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

Effects: 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.

🔗

template<class... TTypes, class... UTypes>
  constexpr common_comparison_category_t<synth-three-way-result<TTypes, UTypes>...>
    operator<=>(const tuple<TTypes...>& t, const tuple<UTypes...>& u);

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  $t_{t a i l}$  <=>  $u_{t a i l}$ ;

where

r_{t a i l}

for some tuple r is a tuple containing all but the first element of r.

[Note

The above definition does not require t

_{t a i l}

(or u

_{t a i l}

) to be constructed.

It may not even be possible, as t and u are not required to be copy constructible.

Also, all comparison functions are short circuited; they do not perform element accesses beyond what is required to determine the result of the comparison.

— end note

]

20.5.9 Tuple traits [tuple.traits]

🔗

template<class... Types, class Alloc>
  struct uses_allocator<tuple<Types...>, Alloc> : true_type { };

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

[Note

Specialization of this trait informs other library components that tuple can be constructed with an allocator, even though it does not have a nested allocator_type.

— end note

]

20.5.10 Tuple specialized algorithms [tuple.special]

🔗

template<class... Types>
  constexpr void swap(tuple<Types...>& x, tuple<Types...>& y) noexcept(see below);

Constraints: is_swappable_v<T> is true for every type T in Types.

Remarks: The expression inside noexcept is equivalent to:

noexcept(x.swap(y))

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