(Comment) puis-je compter les éléments dans une énumération?

Cette question m'est venue à l'esprit, quand j'avais quelque chose comme

enum Folders {FA, FB, FC};

et voulait créer un tableau de conteneurs pour chaque dossier:

ContainerClass*m_containers[3];
....
m_containers[FA] = ...; // etc.

( En utilisant des cartes , il est beaucoup plus élégante à l' utilisation: std::map<Folders, ContainerClass*> m_containers;)

Mais pour revenir à ma question initiale: que se passe-t-il si je ne souhaite pas coder en dur la taille du tableau, existe-t-il un moyen de déterminer le nombre d'éléments dans les dossiers? (Sans compter sur par exempleFC être le dernier élément de la liste, ce qui permettrait quelque chose comme ContainerClass*m_containers[FC+1]si je ne me trompais pas.)

Il n'y a pas vraiment de bon moyen de faire cela, généralement vous voyez un élément supplémentaire dans l'énumération, c'est-à-dire

enum foobar {foo, bar, baz, quz, FOOBAR_NR_ITEMS};

Alors vous pouvez faire:

int fuz[FOOBAR_NR_ITEMS];

Toujours pas très gentil.

Mais bien sûr, vous réalisez que seul le nombre d'éléments dans une énumération n'est pas sûr, étant donné par exemple

enum foobar {foo, bar = 5, baz, quz = 20};

le nombre d'éléments serait de 4, mais les valeurs entières des valeurs d'énumération seraient bien en dehors de la plage d'index du tableau. L'utilisation de valeurs d'énumération pour l'indexation de tableau n'est pas sûre, vous devez envisager d'autres options.

edit: comme demandé, a fait ressortir l'entrée spéciale.

Pour C ++, il existe diverses techniques d'énumération de type sécurisé disponibles, et certaines d'entre elles (comme le Boost.Enum proposé mais jamais soumis ) incluent le support pour obtenir la taille d'une énumération.

L'approche la plus simple, qui fonctionne aussi bien en C qu'en C ++, consiste à adopter une convention de déclaration d'une valeur ... MAX pour chacun de vos types enum:

enum Folders { FA, FB, FC, Folders_MAX = FC };
ContainerClass *m_containers[Folders_MAX + 1];
....
m_containers[FA] = ...; // etc.

Edit : Concernant { FA, FB, FC, Folders_MAX = FC}versus {FA, FB, FC, Folders_MAX]: je préfère définir la valeur ... MAX sur la dernière valeur légale de l'énumération pour plusieurs raisons:

1. Le nom de la constante est techniquement plus précis (car Folders_MAXdonne la valeur d'énumération maximale possible).
2. Personnellement, j'ai l'impression Folders_MAX = FC se démarquer un peu plus des autres entrées (ce qui rend un peu plus difficile d'ajouter accidentellement des valeurs d'énumération sans mettre à jour la valeur maximale, un problème auquel Martin York a fait référence).
3. GCC inclut des avertissements utiles comme "valeur d'énumération non incluse dans le commutateur" pour du code tel que le suivant. Laisser Folders_MAX == FC + 1 annule ces avertissements, car vous vous retrouvez avec un tas de valeurs d'énumération ... MAX qui ne devraient jamais être incluses dans le commutateur.

commutateur (dossier) 
{
  cas FA: ...;
  cas FB: ...;
  // Oups, j'ai oublié FC!
}

Qu'en est-il des traits, à la mode STL? Par exemple:

enum Foo
{
    Bar,
    Baz
};

écrire un

std::numeric_limits<enum Foo>::max()

spécialisation (éventuellement constexpr si vous utilisez c ++ 11). Ensuite, dans votre code de test, fournissez toutes les assertions statiques pour maintenir les contraintes que std :: numeric_limits :: max () = last_item.

Ajoutez une entrée, à la fin de votre énumération, appelée Folders_MAX ou quelque chose de similaire et utilisez cette valeur lors de l'initialisation de vos tableaux.

ContainerClass* m_containers[Folders_MAX];

J'aime utiliser les énumérations comme arguments pour mes fonctions. C'est un moyen simple de fournir une liste fixe d '"options". Le problème avec la réponse la plus votée ici est qu'en utilisant cela, un client peut spécifier une "option invalide". En tant que spin-off, je recommande de faire essentiellement la même chose, mais d'utiliser une constante int en dehors de l'énumération pour en définir le nombre.

enum foobar { foo, bar, baz, quz };
const int FOOBAR_NR_ITEMS=4;

Ce n'est pas agréable, mais c'est une solution propre si vous ne modifiez pas l'énumération sans mettre à jour la constante.

Je ne vois vraiment aucun moyen d'obtenir vraiment le nombre de valeurs dans une énumération en C ++. Toute solution de mention précédente fonctionne tant que vous ne définissez pas la valeur de vos énumérations si vous définissez une valeur que vous pourriez rencontrer dans des situations où vous créez des tableaux trop grands ou trop petits

enum example{ test1 = -2, test2 = -1, test3 = 0, test4 = 1, test5 = 2 }

dans cet exemple, le résultat créerait un tableau de 3 éléments lorsque vous avez besoin d'un tableau de 5 éléments

enum example2{ test1 , test2 , test3 , test4 , test5 = 301 }

dans cet exemple, le résultat créerait un tableau de 301 éléments lorsque vous avez besoin d'un tableau de 5 éléments

La meilleure façon de résoudre ce problème dans le cas général serait de parcourir vos énumérations, mais ce n'est pas encore dans la norme pour autant que je sache