Namespaces
Variants

    std::tuple_size

    De es.cppreference.net
     
    C++
    Soporte de compiladores
    Independiente y alojado
    Lenguaje
    Biblioteca estándar
    Encabezados de la biblioteca estándar
    Requisitos nombrados
    Macros de prueba de características (C++20)
    Biblioteca de soporte del lenguaje
    Biblioteca de conceptos (C++20)
    Biblioteca de diagnóstico
    Biblioteca de gestión de memoria
    Biblioteca de metaprogramación (C++11)
    Biblioteca de utilidades generales
    Biblioteca de contenedores
    Biblioteca de iteradores
    Biblioteca de rangos (C++20)
    Biblioteca de algoritmos
    Biblioteca de cadenas
    Biblioteca de procesamiento de texto
    Biblioteca numérica
    Biblioteca de fecha y hora
    Biblioteca de entrada/salida
    Biblioteca del sistema de archivos (C++17)
    Biblioteca de soporte de concurrencia (C++11)
    Biblioteca de control de ejecución (C++26)
    Especificaciones técnicas
    Índice de símbolos
    Bibliotecas externas
     
    Biblioteca de utilidades
    Soporte del lenguaje
    Soporte de tipos (tipos básicos, RTTI)
    Macros de prueba de características de la biblioteca (C++20)
    Utilidades de programa
    Funciones variádicas
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Soporte de corrutinas (C++20)
    Soporte de contratos (C++26)
    Comparación a tres vías
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Utilidades generales
    Operadores relacionales (obsoleto en C++20)
     
    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; // not defined
    		(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 similar a tuple 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 hacer que un tipo sea similar a tuple.
    2-4) Las especializaciones para tipos con calificación cv reutilizan el valor value de las versiones correspondientes sin calificación cv por defecto.

    std::tuple_size Interactúa con el lenguaje base: puede proporcionar soporte de desestructuración en el caso similar a tuple.

    (2-4) son amigables con SFINAE: si la expresión std::tuple_size<T>::value está mal formada 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
    		(desde C++17)

    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)