Utiliser un enum comme index de tableau

J’ai cette énumération:

enum ButtonState { BUTTON_NORMAL = 0, BUTTON_PRESSED = 1, BUTTON_CLICKED = 2 }; const u8 NUM_BUTTON_STATES = 3; 

Dans ma classe Button, j’ai des variables ButtonState state; et ButtonColors colors[NUM_BUTTON_STATES]; . Lorsque vous dessinez le bouton, j’utilise les colors[state] pour obtenir les couleurs correspondant à l’état du bouton.

Mes questions:

  1. Est-ce un bon style de programmation? Y a-t-il une meilleure façon de le faire? (Je n’utilise généralement que des énumérations avec des instructions de commutateur … l’utilisation d’un enum comme index de tableau ne semble pas correcte.)
  2. Dois-je spécifier les valeurs du enum? Il semble commencer à 0 par défaut et s’incrémenter de 1 mais est-il garanti de fonctionner de cette façon dans tous les compilateurs?

Est-ce un bon style de programmation?

Je le pense. Je fais la même chose assez fréquemment.

Y a-t-il une meilleure façon de le faire?

 class Button { public: // Used for array indexes! Don't change the numbers! enum State { NORMAL = 0, PRESSED, CLICKED, NUMBER_OF_BUTTON_STATES }; }; 

L’inconvénient est que NUMBER_OF_BUTTON_STATES est maintenant une valeur Button :: State valide. Pas un gros problème si vous passez ces valeurs autour de ints . Mais problème si vous attendez réellement un Button :: State .

Utiliser un enum comme index de tableau ne semble pas correct.

C’est bien. Just DOCUMENT , le prochain sait ce qui se passe! (C’est ce que les commentaires sont pour.)

Dois-je spécifier les valeurs du enum?

Sans affectation ‘=’, les enum sont censés commencer à zéro et s’incrémenter vers le haut.

Si une entrée enum a une valeur affectée ‘=’, les entrées non ‘=’ suivantes continuent à partir de là.

Source: Manuel de référence C ++ annoté , p. 113

Cela dit, j’aime spécifier la valeur initiale pour rendre le code plus clair.

Ouais ça va bien marcher. Cela dit, dans tous les cas, vous devez mettre une autre entrée dans votre énumération définissant la valeur de la quantité d’articles:

 enum ButtonState { BUTTON_NORMAL, BUTTON_PRESSED, BUTTON_CLICKED, STATE_COUNT }; 

Ensuite, vous pouvez définir le tableau comme

 Color colors[STATE_COUNT]; 

sinon, il est gênant de garder la quantité d’états synchrone avec la taille du tableau. Les énumérations commenceront toujours par zéro si elles ne sont pas initialisées autrement, puis chaque entrée supplémentaire se verra atsortingbuer une valeur supérieure à la précédente, si elle n’est pas autrement initialisée. Bien sûr, cela ne ferait pas de mal si vous mettez explicitement un zéro si vous voulez. Si cela ne vous dérange pas de code supplémentaire, j’emballerais l’access au tableau brut en utilisant une fonction comme

 Color & operator[](ButtonState state) { return array[state]; } 

Ou une fonction getColor équivalente transférant la requête. Cela interdirait d’indexer directement le tableau avec un nombre entier, ce qui serait presque certainement impossible à un moment donné, car les index ne sont pas corrects.

Utiliser un enum est ok. Mais vous n’avez pas besoin de spécifier des valeurs pour chaque élément. Il suffit de spécifier la première valeur. Je ne suppose pas que les énumérations commencent à 0, car j’ai utilisé des compilateurs qui utilisaient 1 comme valeur de départ (pas pour les PC, mais certains compilateurs pour les microcontrôleurs ont un comportement étrange). En outre, vous pouvez vous débarrasser du const:

 enum ButtonState { BUTTON_NORMAL = 0, BUTTON_PRESSED, BUTTON_CLICKED, NUM_BUTTON_STATES }; 

Question 1: Je pense que c’est un bon style de programmation. Je l’utilise tout le temps. Question 2: Pour autant que je sache, il est garanti de fonctionner de cette façon, vous n’avez donc pas à spécifier les valeurs.

Et je mettrais aussi NUM_BUTTON_STATES dans l’énumération.

Côté style, c’est bien.

Les langages basés sur Pascal, tels que Delphi, permettent de spécifier les limites de tableau en tant que type enum. Vous ne pouvez donc utiliser que les éléments de ce type en tant qu’index.

Il est parfaitement normal d’utiliser un enum pour l’indexation dans un tableau.

Vous n’avez pas besoin de spécifier chaque valeur enum, elles seront automatiquement incrémentées par 1. Si le compilateur choisit les valeurs, cela réduit le risque de fautes de frappe et de création de bogue, mais cela vous prive de voir les valeurs utiles au débogage.

C’est bien, mais je voudrais faire quelques vérifications sur le tableau, comme si quelqu’un ajoutait un autre ButtonState, vous auriez un problème.

De plus, les éléments du tableau de couleurs sont immuables, alors essayez peut-être d’utiliser une autre collection pour pouvoir appliquer cette immuabilité. Peut-être un Dictionary