# std::tuple_size

From cppreference.com
< cpp‎ | utility

Defined in header `<tuple>` |  |
Defined in header `<array>` |  |
Defined in header `<utility>` |  |
Defined in header `<ranges>` |  | (since C++20)
template< class T > struct tuple_size; // not defined | (1) | (since C++11)
template< class T > struct tuple_size< const T > : std::integral_constant<std::size_t, std::tuple_size<T>::value> {}; | (2) | (since C++11)
template< class T > struct tuple_size< volatile T > : std::integral_constant<std::size_t, std::tuple_size<T>::value> {}; | (3) | (since C++11) (deprecated in C++20)
template< class T > struct tuple_size< const volatile T > : std::integral_constant<std::size_t, std::tuple_size<T>::value> {}; | (4) | (since C++11) (deprecated in C++20)

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

1) The primary template is not defined. An explicit (full) or partial specialization is required to make a type tuple-like.
2-4) Specializations for a cv-qualified types reuse the `value` from the corresponding cv-unqualified versions by default.

`std::tuple_size` interacts with the core language: it can provide structured binding support in the tuple-like case. (2-4) are SFINAE-friendly: if std::tuple_size<T>::value is ill-formed when treated as an unevaluated operand, they 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(); // structured binding declaration first attempts
                             // tuple_size<const X> which attempts to use tuple_size<X>::value,
                             // then soft error encountered, binds to public data members
| (since C++17)

### Specializations

The standard library provides following specializations for standard library types:

std::tuple_size<std::tuple> (C++11) | obtains the size of `tuple` at compile time (class template specialization)
std::tuple_size<std::pair> (C++11) | obtains the size of a `pair` (class template specialization)
std::tuple_size<std::array> (C++11) | obtains the size of an `array` (class template specialization)
std::tuple_size<std::ranges::subrange> (C++20) | obtains the number of components of a std::ranges::subrange (class template specialization)

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

Users may specialize `std::tuple_size` for program-defined types to make them tuple-like. Program-defined specializations must meet the requirements above.

Usually only specialization for cv-unqualified types are needed to be customized.

### Helper variable template

Defined in header `<tuple>` |  |
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] | for a standard specialization, the number of elements in the tuple-like type `T` (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 <array>
    #include <cstddef>
    #include <ranges>
    #include <tuple>
    #include <utility>

    template<class T, std::size_t Size> struct Arr { T data[Size]; };
    // a program-defined specialization of std::tuple_size:
    template<class T, std::size_t Size> struct std::tuple_size<Arr<T, Size>>
        : public integral_constant<std::size_t, Size> {};

    int main()
    {
        using tuple1 = std::tuple<int, char, double>;
        static_assert(3 == std::tuple_size_v<tuple1>); // uses using template (C++17)

        using array3x4 = std::array<std::array<int, 3>, 4>;
        static_assert(4 == std::tuple_size<array3x4>{}); // uses operator std::size_t

        using pair = std::pair<tuple1, array3x4>;
        static_assert(2 == std::tuple_size<pair>()); // uses operator()

        using sub = std::ranges::subrange<char*, char*>;
        static_assert(2 == std::tuple_size<sub>::value);

        using Arr5 = Arr<int, 5>;
        static_assert(5 == std::tuple_size_v<Arr5>);
    }

### Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR | Applied to | Behavior as published | Correct behavior
--- | --- | --- | ---
LWG 2212 | C++11 | specializations for cv types were not required in some headers, which led to ambiguity | required

### See also

Structured binding (C++17) | binds the specified names to sub-objects or tuple elements of the initializer
tuple_element (C++11) | obtains the element types of a tuple-like type (class template)
tuple_cat (C++11) | creates a `tuple` by concatenating any number of tuples (function template)

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/utility/tuple_size&oldid=152393"