std::tuple_size

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios 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 apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de servicios

Apoyo del lenguaje Apoyo de tipos (tipos básicos, RTTI) Biblioteca de macros de prueba de característica (C++20) Servicios del programa Apoyo de corrutinas (C++20) Funciones variádicas is_constant_evaluated (C++20) is_within_lifetime (C++26) initializer_list (C++11) source_location (C++20) Comparación de tres vías three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Servicios generales Objetos función Manipulación de bits (C++20) bitset hash (C++11) Operadores relacionales (en desuso en C++20) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Funciones de comparación de enteros cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Intercambio y operaciones de tipos swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Tipos vocabulario comunes pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

<tbody> </tbody>

Definido en el archivo de encabezado <tuple>
Definido en el archivo de encabezado <array>
Definido en el archivo de encabezado <utility>
Definido en el archivo de encabezado <ranges>		(desde C++20)
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) (en desuso 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) (en desuso en C++20)

See More

Proporciona acceso a la cantidad de elementos en un tipo similar a una tupla como una expresión constante en tiempo de compilación.

1) La plantilla principal no está definida. Se requiere una especialización explícita (total) o parcial para hacer un tipo similar a una tupla.

2-4) Las especializaciones para tipos calificados-cv reutilizan por defecto value de las versiones no calificadas-cv correspondientes.

std::tuple_size interactúa con el lenguaje central: puede proporcionar apoyo de vínculo estructurado en el caso similar a una tupla. (2-4) son amigables para SFINAE: si std::tuple_size<T>::value está mal formado cuando se trata como un operando no evaluado, no proporciona el miembro value. La verificación de acceso se realiza como si estuviera en un contexto no relacionado con tuple_size y T. Sólo 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(); // primeros intentos de declaración de vínculo estructurado // tuple_size<const X> que intenta usar tuple_size<X>::value, // entonces se encuentra un error simple, se vincula a los datos // datos miembro públicos

(desde C++17)

Especializaciones

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

tuple_size	Obtiene el tamaño de una tupla en tiempo de compilación. (especialización de plantilla de clase)
std::tuple_size<std::pair> (C++11)	Obtiene el tamaño de un par. (especialización de plantilla de clase)
std::tuple_size<std::array>	obtiene el tamaño de un array Original: obtains the size of an array The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (especialización de plantilla de clase)
std::tuple_size<std::ranges::subrange> (C++20)	Obtiene el número de componentes de un subrango (std::ranges::subrange). (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 algunos { {tt|N}}.

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

Por lo general, para personalizar solo se necesita la especialización para tipos no calificados-cv.

Plantilla de variable auxiliar

<tbody> </tbody>

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

Heredado de std::integral_constant

Constantes miembro

value [estático]

Para una especialización estándar, el número de elementos en el tipo similar a una 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

Ejecuta 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]; };
// una 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>); // utiliza using template (C++17)

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

    using pair = std::pair<tuple1, array3x4>;
    static_assert(2 == std::tuple_size<pair>()); // utiliza 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 de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

ID	Aplicado a	Comportamiento según lo publicado	Comportamiento correcto
LWG 2212	C++11	No se requerían las especializaciones para tipos cv en algunos archivos de encabezado, lo que conducía a ambigüedad.	Se requiere.

Véase también

Vínculo estructurado (C++17)	Vincula los nombres especificados a subobjetos o elementos de una tupla del inicializador.
tuple_element (C++11)	Obtiene los tipos de elementos de un tipo similar a una tupla. (plantilla de clase)
tuple_cat	Crea una tupla mediante la concatenación de cualquier número de tuplas. (plantilla de función)