Standard library header <tuple> - cppreference.com

##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# Standard library header <tuple>

From cppreference.com
< cpp‎ | header

This header is part of the general utility library.

### Classes
tuple (C++11) | implements fixed size container, which holds elements of possibly different types (class template) [edit]
tuple_size | obtains the size of `tuple` at compile time (class template specialization) [edit]
tuple_element | obtains the type of the specified element (class template specialization) [edit]
std::uses_allocator<std::tuple> (C++11) | specializes the std::uses_allocator type trait (class template specialization) [edit]
### Constants
ignore | placeholder to skip an element when unpacking a `tuple` using `tie` (constant) [edit]
### Functions
make_tuple | creates a `tuple` object of the type defined by the argument types (function template) [edit]
tie | creates a `tuple` of lvalue references or unpacks a tuple into individual objects (function template) [edit]
forward_as_tuple | creates a `tuple` of rvalue references (function template) [edit]
tuple_cat | creates a `tuple` by concatenating any number of tuples (function template) [edit]
std::get(std::tuple) | tuple accesses specified element (function template) [edit]
operator==operator!=operator<operator<=operator>operator>= | lexicographically compares the values in the tuple (function template) [edit]
std::swap(std::tuple) (C++11) | specializes the std::swap algorithm (function template) [edit]
apply (C++17) | calls a function with a tuple of arguments (function template) [edit]
make_from_tuple (C++17) | Construct an object with a tuple of arguments (function template) [edit]

### [edit] 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;
    }

#### [edit] 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(see below );
    };

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/header/tuple&oldid=88778"