Standard library header <tuple>

From cppreference.com
< cpp‎ | 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:
    inline constexpr /*unspecified*/ ignore;
    template <class... Types>
        constexpr tuple<VTypes...> make_tuple(Types&&...);
    template <class... Types>
        constexpr tuple<Types...> forward_as_tuple(Types&&...) noexcept;
    template<class... Types>
        constexpr tuple<Types&...> tie(Types&...) noexcept;
    template <class... Tuples>
        constexpr 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>
        constexpr bool operator==(const tuple<TTypes...>&, const tuple<UTypes...>&);
    template<class... TTypes, class... UTypes>
        constexpr bool operator<(const tuple<TTypes...>&, const tuple<UTypes...>&);
    template<class... TTypes, class... UTypes>
        constexpr bool operator!=(const tuple<TTypes...>&, const tuple<UTypes...>&);
    template<class... TTypes, class... UTypes>
        constexpr bool operator>(const tuple<TTypes...>&, const tuple<UTypes...>&);
    template<class... TTypes, class... UTypes>
        constexpr bool operator<=(const tuple<TTypes...>&, const tuple<UTypes...>&);
    template<class... TTypes, class... UTypes>
        constexpr 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>
        constexpr 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>
  constexpr tuple(allocator_arg_t, const Alloc& a);
  template <class Alloc>
  /*conditionally-explicit*/ constexpr
  tuple(allocator_arg_t, const Alloc& a, const Types&...);
  template <class Alloc, class... UTypes>
  /*conditionally-explicit*/ constexpr
  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>
  /*conditionally-explicit*/ constexpr
  tuple(allocator_arg_t, const Alloc& a, const tuple<UTypes...>&);
  template <class Alloc, class... UTypes>
  /*conditionally-explicit*/ constexpr
  tuple(allocator_arg_t, const Alloc& a, tuple<UTypes...>&&);
  template <class Alloc, class U1, class U2>
  /*conditionally-explicit*/ constexpr
  tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&);
  template <class Alloc, class U1, class U2>
  /*conditionally-explicit*/ constexpr
  tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&);
 
  // 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
  constexpr void swap(tuple&) noexcept(/*conditional*/);
};