std::tuple_size<std::tuple>

Defined in header `<tuple>`
template< class T > class tuple_size; /undefined/	(1)	(since C++11)
template< class... Types > class tuple_size< std::tuple<Types...> > : public std::integral_constant<std::size_t, sizeof...(Types)> { };	(2)	(since C++11)
Defined in header `<tuple>`
Defined in header `<array>`		(since C++17)
Defined in header `<utility>`		(since C++17)
Defined in header `<ranges>`		(since C++20)
Defined in header `<span>`		(since C++20)
template< class T > class tuple_size<const T> : public std::integral_constant<std::size_t, tuple_size<T>::value> { };	(3)	(since C++11)
template< class T > class tuple_size< volatile T > : public std::integral_constant<std::size_t, tuple_size<T>::value> { };	(4)	(since C++11)
template< class T > class tuple_size< const volatile T > : public std::integral_constant<std::size_t, tuple_size<T>::value> { };	(5)	(since C++11)

Provides access to the number of elements in a tuple as a compile-time constant expression.

In addition to being available via inclusion of the <tuple> header, the templates (3-5) are available when either of the headers <array> or <utility> are included.

All specializations of std::tuple_size satisfy UnaryTypeTrait with BaseCharacteristic std::integral_constant<std::size_t, N> for some N.

The cv-T templates (3-5) are SFINAE-friendly: if std::tuple_size<T>::value is ill-formed when treated as an unevaluated operand, (3-5) do not provide the member value. Access checking is performed as if in a context unrelated to tuple_size and T. Only the validity of the immediate context of the expression is considered. This allows

#include <utility>
struct X { int a, b; };
const auto [x, y] = X(); // decomposition declaration first attempts tuple_size<const X>
                         // which attempts to use tuple_size<X>::value, and that's OK

(since C++17)

Helper variable template

template< class T > inline constexpr std::size_t tuple_size_v = tuple_size<T>::value;		(since C++17)

Inherited from std::integral_constant

Member constants

value

[static]

sizeof...(Types)
(public static member constant)

Member functions

operator std::size_t	converts the object to std::size_t, returns `value` (public member function)
operator() (C++14)	returns `value` (public member function)

Member types

Type	Definition
`value_type`	`std::size_t`
`type`	std::integral_constant<std::size_t, value>

Example

Run this code

#include <iostream>
#include <tuple>
 
template <class T>
void test(T t)
{
    int a[std::tuple_size<T>::value]; // can be used at compile time
 
    std::cout << std::tuple_size<T>::value << '\n'; // or at run time
}
 
int main()
{
    test(std::make_tuple(1, 2, 3.14));
}

Output:

Language
Standard Library Headers
Freestanding and hosted implementations
Named requirements
Language support library
Concepts library (C++20)
Diagnostics library
Utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms 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

Member functions
tuple::tuple
tuple::operator=
tuple::swap
Non-member functions
make_tuple
tie
forward_as_tuple
tuple_cat
operator==operator!=operator<operator<=operator>operator>=
std::swap
get
Deduction guides(C++17)
Helper classes
tuple_size
tuple_element
uses_allocator
ignore

std::tuple_size<std::array>	obtains the size of an `array` (class template specialization)
std::tuple_size<std::pair> (C++11)	obtains the size of a `pair` (class template specialization)
std::get(std::tuple)	tuple accesses specified element (function template)
tuple_element	obtains the type of the specified element (class template specialization)