Standard library header <tuple>

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

 

Standard Library header files

Language Support
<cstddef> <limits> <climits> <cfloat> <cstdint> <new> <typeinfo> <exception> <ciso646>	<initializer_list> <csignal> <csetjmp> <cstdalign> <cstdarg> <cstdbool> <cstdlib> <ctime>
Diagnostics
<stdexcept> <cassert>	<cerrno> <system_error>
General utilities
<utility> <tuple> <bitset> <memory> <cstdlib> <cstring> <functional>	<type_traits> <ratio> <chrono> <ctime> <scoped_allocator> <typeindex>
Strings
<string> <cctype> <cwctype> <cstring>	<cwchar> <cstdlib> <cuchar>
Localization
<locale> <codectv> <clocale>

Containers
<array> <deque> <forward_list> <list> <vector> <map>	<set> <unordered_map> <unordered_set> <queue> <stack>
Iterators
<iterator>
Algorithms
<algorithm>	<cstdlib>
Numerics
<cfenv> <complex> <random> <valarray>	<numeric> <cmath> <ctgmath> <cstdlib>
Input/Output
<iosfwd> <iostream> <ios> <streambuf> <istream> <ostream>	<iomanip> <sstream> <fstream> <cstdio> <cinttypes>
Regular expressions
<regex>
Thread support
<thread> <mutex> <atomic>	<condition_variable> <future>

 

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)
tuple_size	obtains the size of tuple at compile time (class template specialization)
tuple_element	obtains the type of the specified element (class template specialization)
std::uses_allocator<std::tuple> (C++11)	specializes the std::uses_allocator type trait (class template specialization)
Constants
ignore	placeholder to skip an element when unpacking a tuple using tie (constant)
Functions
make_tuple	creates a tuple object of the type defined by the argument types (function template)
tie	creates a tuple of lvalue references or unpacks a tuple into individual objects (function template)
forward_as_tuple	creates a tuple of rvalue references (function template)
tuple_cat	creates a tuple by concatenating any number of tuples (function template)
std::get(std::tuple)	tuple accesses specified element (function template)
operator== operator!= operator< operator<= operator> operator>=	lexicographically compares the values in the tuple (function template)
std::swap(std::tuple) (C++11)	specializes the std::swap algorithm (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<Ctypes...> tuple_cat(Tuples&&...);
 
    //  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>
        typename tuple_element<I, tuple<Types...> >::type& get(tuple<Types...>&) noexcept;
    template <size_t I, class... types>
        typename tuple_element<I, tuple<Types...> >::type&& get(tuple<Types...>&&) noexcept;
    template <size_t I, class... types>
        typename tuple_element<I, tuple<Types...> >::type const& get(const tuple<Types...>&) 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));
}

Class std::tuple

template <class... Types>
class tuple {
public:
    // tuple construction
    constexpr tuple();
    explicit tuple(const Types&...);
    template <class... UTypes>
        explicit tuple(UTypes&&...);
    tuple(const tuple&) = default;
    tuple(tuple&&) = default;
    template <class... UTypes>
        tuple(const tuple<UTypes...>&); 
    template <class... UTypes>
        tuple(tuple<UTypes...>&&);
    template <class U1, class U2>
        tuple(const pair<U1, U2>&);  // iff sizeof...(Types) == 2
    template <class U1, class U2>
        tuple(pair<U1, U2>&&);       // iff sizeof...(Types) == 2
 
    // allocator-extended constructors
    template <class Alloc>
        tuple(allocator_arg_t, const Alloc& a);
    template <class Alloc>
        tuple(allocator_arg_t, const Alloc& a, const Types&...);
    template <class Alloc, class... UTypes>
        tuple(allocator_arg_t, const Alloc& a, const 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>
        tuple(allocator_arg_t, const Alloc& a, const tuple<UTypes...>&);
    template <class Alloc, class... UTypes>
        tuple(allocator_arg_t, const Alloc& a, tuple<UTypes...>&&);
    template <class Alloc, class U1, class U2>
        tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&);
    template <class Alloc, class U1, class U2>
        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>&); // iff sizeof...(Types) == 2
    template <class U1, class U2>
        tuple& operator=(pair<U1, U2>&&) noexcept; // iff sizeof...(Types) == 2
 
    // tuple swap
    void swap(tuple&) noexcept(see below);
};