Namespaces
Variants

std:: tuple_size

From cppreference.net
Utilities library
Определено в заголовочном файле <array>
Определено в заголовочном файле <tuple>
Определено в заголовочном файле <utility>
Определено в заголовочном файле <ranges>
(начиная с C++20)
Определено в заголовочном файле <complex>
(начиная с C++26)
template < class T >
struct tuple_size ; // не определено
(1) (начиная с C++11)
template < class T >

struct tuple_size < const T >

: std:: integral_constant < std:: size_t , std :: tuple_size < T > :: value > { } ;
(2) (начиная с C++11)
template < class T >

struct tuple_size < volatile T >

: std:: integral_constant < std:: size_t , std :: tuple_size < T > :: value > { } ;
(3) (начиная с C++11)
(устарело в C++20)
template < class T >

struct tuple_size < const volatile T >

: std:: integral_constant < std:: size_t , std :: tuple_size < T > :: value > { } ;
(4) (начиная с C++11)
(устарело в C++20)

Предоставляет доступ к количеству элементов в tuple-like типе в виде константного выражения времени компиляции.

1) Первичный шаблон не определён. Для того чтобы тип был кортежеподобным, требуется явная (полная) или частичная специализация.
2-4) Специализации для cv-квалифицированных типов по умолчанию используют value из соответствующих cv-неквалифицированных версий.

std::tuple_size взаимодействует с ядром языка: он может предоставлять поддержку структурированных привязок в случае tuple-подобных объектов.

(2-4) являются SFINAE-дружественными: если std :: tuple_size < T > :: value является некорректным при рассмотрении как невычисляемый операнд, они не предоставляют член value . Проверка доступа выполняется так, как если бы она происходила в контексте, не связанном с tuple_size и T . Учитывается только валидность непосредственного контекста выражения. Это позволяет

#include <utility>
struct X { int a, b; };
const auto [x, y] = X(); // объявление структурированной привязки сначала пытается использовать
                         // tuple_size<const X>, который пытается использовать tuple_size<X>::value,
                         // затем встречается мягкая ошибка, привязывается к публичным членам данных
(since C++17)

Содержание

Специализации

Стандартная библиотека предоставляет следующие специализации для типов стандартной библиотеки:

получает размер

tuple
(специализация шаблона класса)

получает размер pair
(специализация шаблона класса)
получает размер array
(специализация шаблона класса)
получает размер std::ranges::subrange
(специализация шаблона класса)
получает размер std::complex
(специализация шаблона класса)

Все специализации std::tuple_size удовлетворяют требованиям UnaryTypeTrait с базовой характеристикой std:: integral_constant < std:: size_t , N > для некоторого N .

Пользователи могут специализировать std::tuple_size для программно-определенных типов, чтобы сделать их похожими на кортежи. Программно-определенные специализации должны соответствовать указанным выше требованиям.

Обычно требуется настраивать только специализации для типов без cv-квалификаторов.

Шаблон вспомогательной переменной

Определено в заголовочном файле <tuple>
template < class T >
constexpr std:: size_t tuple_size_v = tuple_size < T > :: value ;
(начиная с C++17)

Наследуется от std:: integral_constant

Константы-члены

value
[static]
для стандартной специализации, количество элементов в кортежеподобном типе T
(public static member constant)

Функции-члены

operator std::size_t
преобразует объект в std:: size_t , возвращает value
(public member function)
operator()
(C++14)
возвращает value
(public member function)

Типы-члены

Тип Определение
value_type std:: size_t
type std:: integral_constant < std:: size_t , value >

Пример

#include <array>
#include <cstddef>
#include <ranges>
#include <tuple>
#include <utility>
template<class T, std::size_t Size> struct Arr { T data[Size]; };
// Пользовательская специализация 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>); // использует using template (C++17)
    using array3x4 = std::array<std::array<int, 3>, 4>;
    static_assert(4 == std::tuple_size<array3x4>{}); // использует operator std::size_t
    using pair = std::pair<tuple1, array3x4>;
    static_assert(2 == std::tuple_size<pair>()); // использует 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>);
}

Отчеты о дефектах

Следующие отчеты об изменениях поведения, влияющие на дефекты, были применены ретроактивно к ранее опубликованным стандартам C++.

DR Applied to Behavior as published Correct behavior
LWG 2212 C++11 специализации для cv-типов не требовались в некоторых заголовках, что приводило к неоднозначности требуются

Смотрите также

Structured binding (C++17) связывает указанные имена с подобъектами или элементами кортежа инициализатора
получает типы элементов кортежеподобного типа
(шаблон класса)
(C++11)
создает tuple путем объединения любого количества кортежей
(шаблон функции)