Namespaces
Variants

std:: tuple_size

From cppreference.net
C++
Utilities library
Definido en el encabezado <array>
Definido en el encabezado <tuple>
Definido en el encabezado <utility>
Definido en el encabezado <ranges>
(desde C++20)
Definido en el encabezado <complex>
(desde C++26)
template < class T >
struct tuple_size ; // no definido
(1) (desde C++11)
template < class T >

struct tuple_size < const T >

: std:: integral_constant < std:: size_t , std :: tuple_size < T > :: value > { } ;
(2) (desde C++11)
template < class T >

struct tuple_size < volatile T >

: std:: integral_constant < std:: size_t , std :: tuple_size < T > :: value > { } ;
(3) (desde C++11)
(obsoleto en C++20)
template < class T >

struct tuple_size < const volatile T >

: std:: integral_constant < std:: size_t , std :: tuple_size < T > :: value > { } ;
(4) (desde C++11)
(obsoleto en C++20)

Proporciona acceso al número de elementos en un tipo tuple-like como una expresión constante en tiempo de compilación.

1) La plantilla principal no está definida. Se requiere una especialización explícita (completa) o parcial para que un tipo sea similar a una tupla.
2-4) Las especializaciones para tipos calificados con cv reutilizan el value de las versiones correspondientes sin calificación cv por defecto.

std::tuple_size interactúa con el núcleo del lenguaje: puede proporcionar structured binding support en el caso tipo-tupla.

(2-4) son compatibles con SFINAE: si std :: tuple_size < T > :: value es mal formado cuando se trata como un operando no evaluado, no proporcionan el miembro value . La verificación de acceso se realiza como si estuviera en un contexto no relacionado con tuple_size y T . Solo se considera la validez del contexto inmediato de la expresión. Esto permite 

#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)

Contenidos

Especializaciones

La biblioteca estándar proporciona las siguientes especializaciones para los tipos de biblioteca estándar:

(C++11)
obtiene el tamaño de

un tuple
(especialización de plantilla de clase)

(C++11)
obtiene el tamaño de un pair
(especialización de plantilla de clase)
(C++11)
obtiene el tamaño de un array
(especialización de plantilla de clase)
(C++20)
obtiene el tamaño de un std::ranges::subrange
(especialización de plantilla de clase)
(C++26)
obtiene el tamaño de un std::complex
(especialización de plantilla de clase)

Todas las especializaciones de std::tuple_size satisfacen UnaryTypeTrait con característica base std:: integral_constant < std:: size_t , N > para algún N .

Los usuarios pueden especializar std::tuple_size para tipos definidos por el programa para hacerlos similares a tuplas. Las especializaciones definidas por el programa deben cumplir con los requisitos anteriores.

Normalmente solo es necesario personalizar las especializaciones para tipos sin calificadores cv.

Plantilla de variable auxiliar

Definido en el encabezado <tuple>
template < class T >
constexpr std:: size_t tuple_size_v = tuple_size < T > :: value ;
(desde C++17)

Heredado de std:: integral_constant

Constantes miembro

value
[static]
para una especialización estándar, el número de elementos en el tipo tipo-tupla T
(constante miembro pública estática)

Funciones miembro

operator std::size_t
convierte el objeto a std:: size_t , devuelve value
(función miembro pública)
operator()
(C++14)
devuelve value
(función miembro pública)

Tipos miembro

Tipo Definición
value_type std:: size_t
type std:: integral_constant < std:: size_t , value >

Ejemplo

Ejecutar este código 
#include <array>
#include <cstddef>
#include <ranges>
#include <tuple>
#include <utility>
template<class T, std::size_t Size> struct Arr { T data[Size]; };
// Especialización definida por el programa de 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>); // usa plantilla using (C++17)
    using array3x4 = std::array<std::array<int, 3>, 4>;
    static_assert(4 == std::tuple_size<array3x4>{}); // usa operator std::size_t
    using pair = std::pair<tuple1, array3x4>;
    static_assert(2 == std::tuple_size<pair>()); // usa 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>);
}

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 2212 C++11 las especializaciones para tipos cv no eran requeridas en algunos encabezados, lo que llevaba a ambigüedad requerido

Véase también

Structured binding (C++17) enlaza los nombres especificados a subobjetos o elementos de tupla del inicializador
(C++11)
obtiene los tipos de elemento de un tipo similar a tupla
(class template)
(C++11)
crea un tuple concatenando cualquier número de tuplas
(function template)