Standard library header <tuple>
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) |
|
(C++11) | 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) |
|
(C++11) | specializes the std::swap algorithm (function template) |
(C++17) | calls a function with a tuple of arguments (function template) |
(C++17) | 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*/);
};
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
http://en.cppreference.com/w/cpp/header/tuple