`<tuple>`

[added with C++11]

forward_as_tuple · get · ignore · make_tuple · swap · tie · tuple · tuple_cat · tuple_element · tuple_size

operator== · operator!= · operator< · operator<= · operator> · operator>=

Include the TR1 header <tuple> to define a template tuple whose instances hold objects of varying types.

Note: Beginning with C++11, this header makes extensive use of variadic templates, indicated by various uses of ellipsis (...). The descriptions below use variadic notation, but still apply to older compilers, provided the number of parameters in a varying-length list does not exceed ten.

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

template<size_t Idx, class Ty>
    class tuple_element; // not defined
template<size_t Idx, class... Types>
    class tuple_element<Idx, tuple<Types...> >;
template<size_t Idx, class... Types> [added with C++11]
    class tuple_element<Idx, const tuple<Types...> >;
template<size_t Idx, class... Types> [added with C++11]
    class tuple_element<Idx, volatile tuple<Types...> >;
template<size_t Idx, class... Types> [added with C++11]
    class tuple_element<Idx, const volatile tuple<Types...> >;

template<class Ty>
    class tuple_size; // not defined
template<class... Types>
    class tuple_size<tuple<Types...> >;
template<class... Types> [added with C++11]
    class tuple_size<const tuple<Types...> >;
template<class... Types> [added with C++11]
    class tuple_size<volatile tuple<Types...> >;
template<class... Types> [added with C++11]
    class tuple_size<const volatile tuple<Types...> >;

    // TEMPLATE FUNCTIONS
template<size_t Idx, class... Types>
    typename tuple_element<Idx, tuple<Types...> >::type&
        get(tuple<Types...&> tpl);
template<size_t Idx, class... Types>
    typename tuple_element<Idx, tuple<Types...> >::type&
        get(const tuple<Types...&> tpl);
template<size_t Idx, class... Types> [added with C++11]
    typename tuple_element<Idx, tuple<Types...> >::type&&
        get(tuple<Types...&>&& tpl);

template<class... Types> [added with C++11]
    tuple<Types&&...>
        forward_as_tuple(Types&&... Args) noexcept;
template<class... Types>
    tuple<Types2...>
        make_tuple(Types...);
template<class... Types>
    tuple<Types&...>
        tie(Types&...) noexcept;

template<class... Tuples> [added with C++11]
    tuple<Types>
        tuple_cat(Tuples&&... tpls);

template<class... Types>
    void swap(tuple<Types...&> left,
        tuple<Types...&> right)
            noexcept(left.swap(right));

    // TEMPLATE COMPARISON OPERATORS
template<class... Types1, class... Types2>
    bool operator==(const tuple<Types1...>& tpl1,
        const tuple<Types2...>& tpl2);
template<class... Types1, class... Types2>
    bool operator!=(const tuple<Types1...>& tpl1,
        const tuple<Types2...>& tpl2);
template<class... Types1, class... Types2>
    bool operator<(const tuple<Types1...>& tpl1,
        const tuple<Types2...>& tpl2);
template<class... Types1, class... Types2>
    bool operator>=(const tuple<Types1...>& tpl1,
        const tuple<Types2...>& tpl2);
template<class... Types1, class... Types2>
    bool operator>(const tuple<Types1...>& tpl1,
        const tuple<Types2...>& tpl2);
template<class... Types1, class... Types2>
    bool operator<=(const tuple<Types1...>& tpl1,
        const tuple<Types2...>& tpl2);

    // CONST OBJECTS
const T1 ignore;

    namespace tr1 {
using std::get; using std::ignore; [added with C++11]
using std::make_tuple; using std::ref;
using std::tie; using std::tuple;
using std::tuple_cat; using std::tuple_element;
using std::tuple_size;
    }  // namespace tr1
}  // namespace std

`forward_as_tuple`

template<class... Types> [added with C++11]
    tuple<Types&&...>
        forward_as_tuple(Types&&... Args) noexcept;

The template function returns tuple<Types&&...>(forward<Types>(Args)...)

`get`

template<size_t Idx, class... Types>
    typename tuple_element<Idx, tuple<Types...> >::type&
        get(tuple<Types...&> tpl);
template<size_t Idx, class... Types>
    typename tuple_element<Idx, tuple<Types...> >::type&
        get(const tuple<Types...&> tpl);
template<size_t Idx, class... Types> [added with C++11]
    typename tuple_element<Idx, tuple<Types...> >::type&&
        get(tuple<Types...&>&& tpl);

The template functions each return a reference to the value at index Idx in the tuple object tpl. If the corresponding type Ti in Types is a reference type, all functions return Ti; otherwise the first function returns Ti& the second function returns const Ti&, and the third function returns Ti&&.

`ignore`

const T1 ignore;

The object has unspecified type T1 and can be assigned anything with no effect. Note that ignore& can make a useful placeholder in a tuple object.

`make_tuple`

template<class... Types>
    tuple<Types2...>
        make_tuple(Types...);

The template function returns a tuple object constructed from the argument list, where each element type T2i in Types2 is determined from the corresponding Ti in Types as follows:

If Ti is any const/volatile qualified reference_wrapper<X>, T2i is X&.
Otherwise, beginning with C++11, T2i is decay<Ti>::type.
Otherwise, T2i is Ti.

`operator==`

template<class... Types1, class... Types2>
    bool operator==(const tuple<Types1...>& tpl1,
        const tuple<Types2...>& tpl2);

The function returns true only when both tuples are empty, or when get<0>(tpl1) == get<0>(tpl2) && ... for all corresponding elements.

`operator!=`

template<class... Types1, class... Types2>
    bool operator!=(const tuple<Types1...>& tpl1,
        const tuple<Types2...>& tpl2);

The function returns !(tpl1 == tpl2).

`operator<`

template<class... Types1, class... Types2>
    bool operator<(const tuple<Types1...>& tpl1,
        const tuple<Types2...>& tpl2);

The function returns true only when both tuples are not empty and get<0>(tpl1) < get<0>(tpl2) || !(get<0>(tpl2) < get<0>(tpl1)) && ... for all corresponding elements.

`operator<=`

template<class... Types1, class... Types2>
    bool operator<=(const tuple<Types1...>& tpl1,
        const tuple<Types2...>& tpl2);

The function returns !(tpl2 < tpl1).

`operator>`

template<class... Types1, class... Types2>
    bool operator>(const tuple<Types1...>& tpl1,
        const tuple<Types2...>& tpl2);

The function returns tpl2 < tpl1.

`operator>=`

template<class... Types1, class... Types2>
    bool operator>=(const tuple<Types1...>& tpl1,
        const tuple<Types2...>& tpl2);

The function returns !(tpl1 < tpl2).

`swap`

template<class... Types>
    void swap(tuple<Types...&> left,
        tuple<Types...&> right)
            noexcept(left.swap(right));

The function executes left.swap(right).

`tie`

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

The template function returns a tuple object constructed from the argument list, where each element is a reference. Note that a reference to ignore can be assigned anything and will do nothing.

`tuple`

template<class... Types>
class tuple {
public:
    constexpr tuple();
    explicit tuple(const Types&...);
    template<class... Types2>
        tuple(const tuple<Types2...>& right);
    template<class U1, class U2>
        tuple(const pair<U1, U2>& right);

    template<class... Types2>
        explicit tuple(Types2...&& args); [added with C++11]

    tuple(tuple&& right); [added with C++11]
    template<class... Types2>
        tuple(tuple<Types2...>&& right); [added with C++11]
    template<class U1, class U2>
        tuple(pair<U1, U2>&& right); [added with C++11]
    tuple(const tuple& right) = default; [added with C++11]

    template<class Alloc>
        tuple(allocator_arg_t, const Alloc& al); [added with C++11]
    template<class Alloc>
        tuple(allocator_arg_t, const Alloc& al,
            const Types&...); [added with C++11]
    template<class Alloc, class... Types2>
        tuple(allocator_arg_t, const Alloc& al,
            const tuple<Types2...>& right); [added with C++11]
    template<class Alloc, class U1, class U2>
        tuple(allocator_arg_t, const Alloc& al,
            const pair<U1, U2>& right); [added with C++11]

    template<class Alloc, class... Types2>
        tuple(allocator_arg_t, const Alloc& al,
            Types2...&& args); [added with C++11]

    template<class Alloc>
        tuple(allocator_arg_t, const Alloc& al,
            tuple&& right); [added with C++11]
    template<class Alloc, class... Types2>
        tuple(allocator_arg_t, const Alloc& al,
            tuple<Types2...>&& right); [added with C++11]
    template<class Alloc, class U1, class U2>
        tuple(allocator_arg_t, const Alloc& al,
            pair<U1, U2>&& right); [added with C++11]
    template<class Alloc>
        tuple(allocator_arg_t, const Alloc& al,
            const tuple& right); [added with C++11]

    tuple& operator=(const tuple& right);
    template<class... Types2>
        tuple& operator=(const tuple<Types2...>& right);
    template<class U1, class U2>
        tuple& operator=(const pair<U1, U2>& right);

    tuple& operator=(tuple&& right); [added with C++11]
    template<class... Types2>
        tuple& operator=(tuple<Types2...>&& right); [added with C++11]
    template<class U1, class U2>
        tuple& operator=(pair<U1, U2>&& right); [added with C++11]

    void swap(tuple& right)
        noexcept(expr); [added with C++11]
    };

The template class describes an object that stores zero or more objects of types specified by Types. The extent of a tuple instance is the number N of its template arguments. The index of the template argument Ti (counting from zero) and of the corresponding stored value of that type is i.

`tuple::operator=`

tuple& operator=(const tuple& right);
template<class... Types2>
    tuple& operator=(const tuple<Types2...>& right);
template<class U1, class U2>
    tuple& operator=(const pair<U1, U2>& right);

tuple& operator=(tuple&& right); [added with C++11]
template<class... Types2>
    tuple& operator=(tuple<Types2...>&& right); [added with C++11]
template<class U1, class U2>
    tuple& operator=(pair<U1, U2>&& right); [added with C++11]

The first two member operators assign the elements of right to the corresponding elements of *this. The third member operator assigns right.first to the element at index 0 of *this and right.second to the element at index 1. All three member operators return *this.

The remaining member operators are analogs to earlier ones, but with rvalue references.

`tuple::swap`

void swap(tuple& right)
    noexcept(expr); [added with C++11]

The member function calls swap for each element of right and the corresponding element of *this.

The noexcept expression expr is true if, for each type Ti in Types... noexcept(swap(decltype<Ti>, decltype<Ti>)). is true.

`tuple::tuple`

tuple();
explicit tuple(const Types&...);
tuple(const tuple& right);
template<class... Types2>
    tuple(const tuple<Types2...>& right);
template<class U1, class U2>
    tuple(const pair<U1, U2>& right);

template<class... Types2>
    explicit tuple(Types2...&& args); [added with C++11]

tuple(tuple&& right); [added with C++11]
template<class... Types2>
    tuple(tuple<Types2...>&& right); [added with C++11]
template<class U1, class U2>
    tuple(pair<U1, U2>&& right); [added with C++11]
tuple(const tuple& right) = default; [added with C++11]

template<class Alloc>
    tuple(allocator_arg_t, const Alloc& al); [added with C++11]
template<class Alloc>
    tuple(allocator_arg_t, const Alloc& al,
        const Types&...); [added with C++11]
template<class Alloc, class... Types2>
    tuple(allocator_arg_t, const Alloc& al,
        const tuple<Types2...>& right); [added with C++11]
template<class Alloc, class U1, class U2>
    tuple(allocator_arg_t, const Alloc& al,
        const pair<U1, U2>& right); [added with C++11]

template<class Alloc, class... Types2>
    tuple(allocator_arg_t, const Alloc& al,
        Types2...&& args); [added with C++11]

template<class Alloc>
    tuple(allocator_arg_t, const Alloc& al,
        tuple&& right); [added with C++11]
template<class Alloc, class... Types2>
    tuple(allocator_arg_t, const Alloc& al,
        tuple<Types2...>&& right); [added with C++11]
template<class Alloc, class U1, class U2>
    tuple(allocator_arg_t, const Alloc& al,
        pair<U1, U2>&& right); [added with C++11]
template<class Alloc>
    tuple(allocator_arg_t, const Alloc& al,
        const tuple& right); [added with C++11]

The first constructor constructs an object whose elements are default constructed. The second constructor constructs an object whose elements are copy constructed from the argument list.

The third and fourth constructors construct an object whose elements are copy constructed from the corresponding element of right. The fifth constructor constructs an object whose element at index 0 is copy constructed from right.first and whose element at index 1 is copy constructed from right.second.

The sixth constructor constructs each of the elements by moving the corresponding argument. The seventh through ninth constructors are analogs to earlier ones, but with rvalue references.

The remaining constructors construct each of the tuple elements (of type Ti, with optional argument Vi) in one of three ways:

If uses_allocator<Ti, Alloc> holds false, then the element is constructed with no additional arguments (just the optional argument Vi).
If uses_allocator<Ti, Alloc> holds true, and is_constructible<Ti, allocator_arg_t, Alloc [, Ti]> holds true, then the optional constructor argument Vi is preceded by the two arguments allocator_arg and al.
If uses_allocator<Ti, Alloc> holds true and is_constructible<Ti, allocator_arg_t, Alloc [, Ti]> holds false, then the optional constructor argument Vi is followed by al.

`tuple_cat`

template<class... Tuples> [added with C++11]
    tuple<Types>
        tuple_cat(Tuples&&... tpls);

The template function returns an object of type tuple<Types...> whose elements are the concatenation of the elements of the arguments tpls....

`tuple_element`

template<size_t Idx, class Ty>
    class tuple_element; // not defined
template<size_t Idx, class... Types>
    class tuple_element<Idx, tuple<Types...> >;
template<size_t Idx, class... Types> [added with C++11]
    class tuple_element<Idx, const tuple<Types...> >;
template<size_t Idx, class... Types> [added with C++11]
    class tuple_element<Idx, volatile tuple<Types...> >;
template<size_t Idx, class... Types> [added with C++11]
    class tuple_element<Idx, const volatile tuple<Types...> >;

The template class has a member type type that is a synonym for the cv-qualified type at index Idx of the type tuple<Types...>.

`tuple_size`

template<class Ty>
    class tuple_size; // not defined
template<class... Types>
    class tuple_size<tuple<Types...> >;
template<class... Types> [added with C++11]
    class tuple_size<const tuple<Types...> >;
template<class... Types> [added with C++11]
    class tuple_size<volatile tuple<Types...> >;
template<class... Types> [added with C++11]
    class tuple_size<const volatile tuple<Types...> >;

The template class has a member const size_t value whose value is the extent of the type tuple<Types...>.

See also the Table of Contents and the Index.