Est-il possible de déterminer le nombre d'éléments d'une classe enum c++ ?

Question

Est-il possible de déterminer la cardinalité d'un fichier c++ ? enum class :

enum class Example { A, B, C, D, E };

J'ai essayé d'utiliser sizeof Cependant, il renvoie la taille d'un élément de l'enum.

sizeof(Example); // Returns 4 (on my architecture)

Existe-t-il un moyen standard d'obtenir la cardinalité (5 dans mon exemple) ?

Answer 1

Non, vous devez l'écrire dans le code.

Answer 2

Il existe un autre moyen qui ne repose pas sur le nombre de lignes ou les modèles. La seule exigence est de placer les valeurs de l'enum dans leur propre fichier et de faire en sorte que le préprocesseur/compilateur fasse le compte comme ceci :

mon_enum_inc.h

ENUMVAL(BANANA)
ENUMVAL(ORANGE=10)
ENUMVAL(KIWI)
...
#undef ENUMVAL

mon_enum.h

typedef enum {
  #define ENUMVAL(TYPE) TYPE,
  #include "my_enum_inc.h"
} Fruits;

#define ENUMVAL(TYPE) +1
const size_t num_fruits =
  #include "my_enum_inc.h"
  ;

Cela vous permet d'ajouter des commentaires aux valeurs de l'énumération, de réaffecter les valeurs et de ne pas injecter une valeur d'énumération "count" invalide qui doit être ignorée ou prise en compte dans le code.

Si vous ne vous souciez pas des commentaires, vous n'avez pas besoin d'un fichier supplémentaire et pouvez faire comme quelqu'un d'autre l'a mentionné plus haut, par exemple :

#define MY_ENUM_LIST \
    ENUMVAL(BANANA) \
    ENUMVAL(ORANGE = 7) \
    ENUMVAL(KIWI)

et remplacer le #include "my_enum_inc.h" avec MY_ENUM_LIST mais vous devrez #undef ENUMVAL après chaque utilisation.

Answer 3

Voici la solution qui a fonctionné pour moi en 2020, en utilisant Visual Studio 2019.

#define Enum(Name, ...)                                                        \
    struct Name {                                                              \
        enum : int {                                                           \
            __VA_ARGS__                                                        \
        };                                                                     \
        private: struct en_size { int __VA_ARGS__; };                          \
        public: static constexpr  size_t count = sizeof(en_size)/sizeof(int);  \
    }   

l'usage :

struct S {

    Enum(TestEnum, a=11, b=22, c=33);

    void Print() {
        std::cout << TestEnum::a << '\n';
        std::cout << TestEnum::b << '\n';
        std::cout << TestEnum::count << '\n';
    }

};

int main()
{        

    S d;
    d.Print();

    return 0
}

sortie :

11
22
3

Answer 4

Vous pouvez également envisager static_cast<int>(Example::E) + 1 ce qui élimine l'élément supplémentaire.