std::tuple_size - cppreference.com

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.

#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

Especializaciones

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

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

Ejemplo

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

Véase también