Standard library header <tuple>

 

C++

Language

Headers

Freestanding and hosted implementations

Named requirements

Language support library

Concepts library (C++20)

Diagnostics library

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)

Filesystem library (C++17)

Technical Specifications

 

Standard Library header files

Language Support
<cstddef> <limits> <climits> <contract>	<cfloat> <cstdint> <new> <version>	<typeinfo> <exception> <initializer_list>	<csignal> <csetjmp> <cstdarg>
Concepts
<concepts>
Diagnostics
<stdexcept>	<cassert>	<cerrno>	<system_error>
General utilities
<utility> <memory> <memory_resource> <scoped_allocator>     <compare>	<bitset> <tuple> <optional> <any> <variant>	<type_traits> <ratio> <chrono> <typeindex> <functional>	<ctime> <cstdlib>
Strings
<string> <string_view>	<cctype> <cwctype>	<cwchar> <cuchar>	<cstring> <charconv>
Localization
<locale>	<codecvt>	<clocale>
Containers
<span> <array> <vector>	<deque> <forward_list> <list>	<map> <set> <queue>	<unordered_map> <unordered_set> <stack>
Iterators
<iterator>
Algorithms
<algorithm>	<execution>
Numerics
<complex> <random>	<valarray> <numeric>	<cfenv> <cmath>	<bit>
Input/Output
<iosfwd> <ios> <iomanip> <streambuf>	<istream> <ostream> <iostream>	<sstream> <fstream> <syncstream>	<cstdio> <cinttypes> <strstream>
Regular expressions
<regex>
Filesystem support
<filesystem>
Thread support
<thread> <atomic>	<mutex> <shared_mutex>	<condition_variable> <future>
C compatibility
<ciso646> <cstdalign>	<cstdbool> <ccomplex>	<ctgmath>

 

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)
apply (C++17)	calls a function with a tuple of arguments (function template)
make_from_tuple (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:
    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;
}

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(/*conditional*/);
};