Namespaces
Variants

    std::variant_size, std::variant_size_v

    Depuis fr.cppreference.net
     
    C++
    Support du compilateur
    Autonome 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 heure
    Bibliothèque d'entrée/sortie
    Bibliothèque du 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 (obsolète en C++20)
     
    std::variant
     
    Défini dans l'en-tête <variant> 
    template< class T >
struct variant_size; /* undefined */
    		(1) (depuis C++17) 
    template< class... Types >
struct variant_size<std::variant<Types...>>
    : std::integral_constant<std::size_t, sizeof...(Types)> {};
    		(2) (depuis C++17) 
    template< class T >
class variant_size<const T>;
    		(3) (depuis C++17) 
    template< class T >
class variant_size<volatile T>;
    		(4) (depuis C++17)
    (obsolète en C++20) 
    template< class T >
class variant_size<const volatile T>;
    		(5) (depuis C++17)
    (obsolète en C++20)

    Fournit l'accès au nombre d'alternatives dans un variant potentiellement qualifié cv en tant qu'expression constante de compilation.

    Formellement,

    2) satisfait aux exigences de UnaryTypeTrait avec une caractéristique de base de std::integral_constant<std::size_t, sizeof...(Types)>
    3-5) satisfait aux exigences de UnaryTypeTrait avec une caractéristique de base de std::integral_constant<std::size_t, std::variant_size<T>::value>

    Modèle de variable d'assistance

    template < class T >
    constexpr std:: size_t variant_size_v = std :: variant_size < T > :: value ;
    		(depuis C++17)

    Hérité de std:: integral_constant

    Constantes membres

    value
    [static]
    		sizeof...(Types)
    (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 >

    Notes

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

    Exemple

    Exécuter ce code 
    #include <any>
#include <variant>
static_assert(std::variant_size_v<std::variant<>> == 0);
static_assert(std::variant_size_v<std::variant<int>> == 1);
static_assert(std::variant_size_v<std::variant<int, int>> == 2);
static_assert(std::variant_size_v<std::variant<int, int, int>> == 3);
static_assert(std::variant_size_v<std::variant<int, float, double>> == 3);
static_assert(std::variant_size_v<std::variant<std::monostate, void>> == 2);
static_assert(std::variant_size_v<std::variant<const int, const float>> == 2);
static_assert(std::variant_size_v<std::variant<std::variant<std::any>>> == 1);
int main() {}

    Voir aussi

    (C++17)
    		obtient le type de l'alternative spécifiée par son index, au moment de la compilation
    (modèle de classe) (modèle d'alias)
    (C++11)
    		obtient la taille de

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