Namespaces
Variants

    std::tuple_size

    Depuis fr.cppreference.net
     
    C++
    Support du compilateur
    Libre et hébergé
    Langage
    Bibliothèque standard
    En-têtes de la bibliothèque standard
    Exigences nommées
    Macros de test de fonctionnalités (C++20)
    Bibliothèque de support du langage
    Bibliothèque de concepts (C++20)
    Bibliothèque de diagnostics
    Bibliothèque de gestion de la mémoire
    Bibliothèque de métaprogrammation (C++11)
    Bibliothèque d'utilitaires généraux
    Bibliothèque de conteneurs
    Bibliothèque d'itérateurs
    Bibliothèque de plages (C++20)
    Bibliothèque d'algorithmes
    Bibliothèque de chaînes
    Bibliothèque de traitement de texte
    Bibliothèque numérique
    Bibliothèque de date et d'heure
    Bibliothèque d'entrée/sortie
    Bibliothèque de système de fichiers (C++17)
    Bibliothèque de support de la concurrence (C++11)
    Bibliothèque de contrôle d'exécution (C++26)
    Spécifications techniques
    Index des symboles
    Bibliothèques externes
     
    Bibliothèque d'utilitaires
    Support du langage
    Support des types (types de base, RTTI)
    Macros de test de fonctionnalités de la bibliothèque (C++20)
    Utilitaires de programme
    Fonctions variadiques
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Support des coroutines (C++20)
    Support des contrats (C++26)
    Comparaison à trois voies
    (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)

    Utilitaires généraux
    Opérateurs relationnels (déprécié en C++20)
     
    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; // not defined
    		(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)
    (déprécié 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)
    (déprécié en C++20)

    Fournit l'accès au nombre d'éléments d'un type semblable à un tuple sous la forme d'une expression constante à la compilation.

    1) Le modèle primaire n'est pas défini. Une spécialisation explicite (totale) ou partielle est nécessaire pour rendre un type semblable à un tuple.
    2-4) Les spécialisations pour les types qualifiés cv réutilisent value des versions non qualifiées cv correspondantes par défaut.

    std::tuple_size interagit avec le langage fondamental : il peut fournir le support de la décomposition structurée dans le cas des types semblables à un 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 si elle se trouvait dans un contexte non lié à 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(); // 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
    		(depuis C++17)

    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)