Namespaces
Variants

std:: tuple_size

From cppreference.net
C++
Utilities library
Défini dans l'en-tête <array>
Défini dans l'en-tête <tuple>
Défini dans l'en-tête <utility>
Défini dans l'en-tête <ranges>
(depuis C++20)
Défini dans l'en-tête <complex>
(depuis C++26)
template < class T >
struct tuple_size ; // non défini
(1) (depuis C++11)
template < class T >

struct tuple_size < const T >

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

struct tuple_size < volatile T >

: std:: integral_constant < std:: size_t , std :: tuple_size < T > :: value > { } ;
(3) (depuis C++11)
(obsolète en C++20)
template < class T >

struct tuple_size < const volatile T >

: std:: integral_constant < std:: size_t , std :: tuple_size < T > :: value > { } ;
(4) (depuis C++11)
(obsolète en C++20)

Fournit l'accès au nombre d'éléments dans un type tuple-like sous forme d'une expression constante évaluée à la compilation.

1) Le modèle principal n'est pas défini. Une spécialisation explicite (complète) ou partielle est requise pour rendre un type tuple-like.
2-4) Les spécialisations pour les types qualifiés cv réutilisent la valeur value des versions correspondantes non qualifiées cv par défaut.

std::tuple_size interagit avec le langage de base : il peut fournir la prise en charge de la liaison structurée dans le cas de type tuple.

(2-4) sont compatibles avec SFINAE : si std :: tuple_size < T > :: value est mal formé lorsqu'il est traité comme un opérande non évalué, ils ne fournissent pas le membre value . La vérification d'accès est effectuée comme dans un contexte sans rapport avec tuple_size et T . Seule la validité du contexte immédiat de l'expression est prise en compte. Cela permet 

#include <utility>
struct X { int a, b; };
const auto [x, y] = X(); // la déclaration de liaison structurée tente d'abord
                         // tuple_size<const X> qui tente d'utiliser tuple_size<X>::value,
                         // puis rencontre une erreur douce, se lie aux membres de données publics
 (depuis C++17)

Table des matières

Spécialisations

La bibliothèque standard fournit les spécialisations suivantes pour les types de la bibliothèque standard :

(C++11)
obtient la taille d'un

tuple
(spécialisation de modèle de classe)

(C++11)
obtient la taille d'une pair
(spécialisation de modèle de classe)
(C++11)
obtient la taille d'un array
(spécialisation de modèle de classe)
(C++20)
obtient la taille d'un std::ranges::subrange
(spécialisation de modèle de classe)
(C++26)
obtient la taille d'un std::complex
(spécialisation de modèle de classe)

Toutes les spécialisations de std::tuple_size satisfont UnaryTypeTrait avec une caractéristique de base std:: integral_constant < std:: size_t , N > pour un certain N .

Les utilisateurs peuvent spécialiser std::tuple_size pour les types définis par le programme afin de les rendre similaires à des tuples. Les spécialisations définies par le programme doivent satisfaire aux exigences ci-dessus.

En général, seules les spécialisations pour les types non qualifiés cv doivent être personnalisées.

Modèle de variable d'assistance

Défini dans l'en-tête <tuple>
template < class T >
constexpr std:: size_t tuple_size_v = tuple_size < T > :: value ;
(depuis C++17)

Hérité de std:: integral_constant

Constantes membres

value
[static]
pour une spécialisation standard, le nombre d'éléments dans le type tuple-like T
(constante membre publique statique)

Fonctions membres

operator std::size_t
convertit l'objet en std:: size_t , retourne value
(fonction membre publique)
operator()
(C++14)
retourne value
(fonction membre publique)

Types membres

Type Définition
value_type std:: size_t
type std:: integral_constant < std:: size_t , value >

Exemple

Exécuter ce code 
#include <array>
#include <cstddef>
#include <ranges>
#include <tuple>
#include <utility>
template<class T, std::size_t Size> struct Arr { T data[Size]; };
// Spécialisation définie par le programme 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>); // utilise le template using (C++17)
    using array3x4 = std::array<std::array<int, 3>, 4>;
    static_assert(4 == std::tuple_size<array3x4>{}); // utilise l'opérateur std::size_t
    using pair = std::pair<tuple1, array3x4>;
    static_assert(2 == std::tuple_size<pair>()); // utilise l'opérateur()
    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>);
}

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR S'applique à Comportement tel que publié Comportement correct
LWG 2212 C++11 les spécialisations pour les types cv n'étaient pas requises dans certains en-têtes, ce qui conduisait à une ambiguïté requis

Voir aussi

Structured binding (C++17) lie les noms spécifiés aux sous-objets ou éléments de tuple de l'initialiseur
(C++11)
obtient les types d'éléments d'un type de type tuple
(modèle de classe)
(C++11)
crée un tuple en concaténant n'importe quel nombre de tuples
(modèle de fonction)