Standard library header <tuple>

From cppreference.com
< cpplrm; | header

This header is part of the general utility library.

Classes

(C++11)
implements fixed size container, which holds elements of possibly different types
(class template)
obtains the size of tuple at compile time
(class template specialization)
obtains the type of the specified element
(class template specialization)
specializes the std::uses_allocator type trait
(class template specialization)

Constants

placeholder to skip an element when unpacking a tuple using tie
(constant)

Functions

creates a tuple object of the type defined by the argument types
(function template)
creates a tuple of lvalue references or unpacks a tuple into individual objects
(function template)
creates a tuple of rvalue references
(function template)
creates a tuple by concatenating any number of tuples
(function template)
tuple accesses specified element
(function template)
lexicographically compares the values in the tuple
(function template)
specializes the std::swap algorithm
(function template)
(C++17)
calls a function with a tuple of arguments
(function template)
Construct an object with a tuple of arguments
(function template)

Synopsis

namespace std {
    // class template tuple:
    template <class... Types> class tuple;

    // tuple creation functions:
    const /*unspecified*/ ignore;
    template <class... Types>
        tuple<VTypes...> make_tuple(Types&&...);
    template <class... Types>
        tuple<Types...> forward_as_tuple(Types&&...) noexcept;
    template<class... Types>
        tuple<Types&...> tie(Types&...) noexcept;
    template <class... Tuples>
        tuple<Tuples...> tuple_cat(Tuples&&...);

    // 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 classes:
    template <class T> class tuple_size; // undefined
    template <class T> class tuple_size<const T>;
    template <class T> class tuple_size<volatile T>;
    template <class T> class tuple_size<const volatile T>;
    template <class... Types> class tuple_size<tuple<Types...> >;

    template <size_t I,  class   T>     class tuple_element; // undefined
    template <size_t I,  class   T>     class tuple_element<I, const T>;
    template <size_t I,  class   T>     class tuple_element<I, volatile T>;
    template <size_t I,  class   T>     class tuple_element<I, const volatile T>;
    template <size_t I, class... Types> class tuple_element<I, tuple<Types...> >;

    //  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;

    //relational operators:
    template<class... TTypes, class... UTypes>
        bool operator==(const tuple<TTypes...>&, const tuple<UTypes...>&);
    template<class... TTypes, class... UTypes>
        bool operator<(const tuple<TTypes...>&, const tuple<UTypes...>&);
    template<class... TTypes, class... UTypes>
        bool operator!=(const tuple<TTypes...>&, const tuple<UTypes...>&);
    template<class... TTypes, class... UTypes>
        bool operator>(const tuple<TTypes...>&, const tuple<UTypes...>&);
    template<class... TTypes, class... UTypes>
        bool operator<=(const tuple<TTypes...>&, const tuple<UTypes...>&);
    template<class... TTypes, class... UTypes>
        bool operator>=(const tuple<TTypes...>&, const tuple<UTypes...>&);

    // allocator-related traits
    template <class... Types, class Alloc>
        struct uses_allocator<tuple<Types...>, Alloc>;
    // specialized algorithms:
    template <class... Types>
        void swap(tuple<Types...>& x, tuple<Types...>& y) noexcept(x.swap(y));
    // tuple helper classes
    template <class T> constexpr size_t tuple_size_v = tuple_size<T>::value;
}

Class std::tuple

template <class... Types>
class tuple {
public:
  // tuple construction
  /*conditionally-explicit*/ constexpr tuple();
  // only if sizeof...(Types) >= 1
  /*conditionally-explicit*/ constexpr tuple(const Types&...); 
  // only if sizeof...(Types) >= 1
  template <class... UTypes>
  /*conditionally-explicit*/ constexpr tuple(UTypes&&...); 
  tuple(const tuple&) = default;
  tuple(tuple&&) = default;
  template <class... UTypes>
  /*conditionally-explicit*/ constexpr tuple(const tuple<UTypes...>&);
  template <class... UTypes>
  /*conditionally-explicit*/ constexpr tuple(tuple<UTypes...>&&);
  // only if sizeof...(Types) == 2
  template <class U1, class U2>
  /*conditionally-explicit*/ constexpr tuple(const pair<U1, U2>&);
  // only if sizeof...(Types) == 2
  template <class U1, class U2>
  /*conditionally-explicit*/ constexpr tuple(pair<U1, U2>&&); 

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

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

  // tuple swap
  void swap(tuple&) noexcept(/*conditional*/);
};