Utiliser une énumération comme un index de tableau

StackOverflow https://stackoverflow.com/questions/404231

  •  03-07-2019
  •  | 
  •  

Question

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 membres Etat de l'état du bouton; et couleurs ButtonColors [NUM_BUTTON_STATES]; . Lorsque je dessine le bouton, j’utilise colors [state] pour obtenir les couleurs de l’état dans lequel se trouve le bouton.

Mes questions:

  1. Ce style de programmation est-il bon? Y a-t-il une meilleure façon de le faire? (J'utilise généralement seulement des énumérations avec des instructions switch ... utiliser une énumération en tant qu'index de tableau ne semble pas correct.)
  2. Dois-je devoir spécifier les valeurs de l'énum? Il semble partir de 0 par défaut et augmenter de 1, mais est-il garanti de fonctionner ainsi avec tous les compilateurs?
Était-ce utile?

La solution

S'agit-il d'un bon style de programmation?

Je pense que oui. Je fais la même chose assez souvent.

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. Ce n’est pas un gros problème si vous transmettez ces valeurs sous la forme ints . Mais problème si vous attendez réellement un Button :: State .

L'utilisation d'un enum en tant qu'indice de tableau ne vous semble pas appropriée.

ça va. Il suffit de le DOCUMENTER pour que le prochain gars sache ce qui se passe! (C’est à quoi servent les commentaires.)

Dois-je spécifier les valeurs de l'énum?

Sans affectation '=', les enum sont supposés commencer à zéro et augmenter progressivement.

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

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

Cela dit, j'aime bien spécifier la valeur initiale simplement pour que le code soit plus clair.

Autres conseils

Oui, cela fonctionnera bien. Cela dit, dans tous les cas, vous vraiment devriez ajouter une autre entrée dans votre énumération, définissant la valeur du nombre d'éléments: 

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 commencent toujours par zéro si elles ne sont pas initialisées autrement, puis chaque entrée supplémentaire se voit attribuer une valeur supérieure à la précédente, sinon initialisée. Bien sûr, cela ne ferait pas de mal non plus de mettre explicitement le zéro à zéro si vous le souhaitez. Si cela ne vous dérange pas de code supplémentaire, je voudrais envelopper l'accès au tableau brut en utilisant une fonction comme 

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

Ou une fonction getColor équivalente transmettant la demande. Cela interdirait d'indexer directement le tableau avec un entier, ce qui entraînerait presque certainement l'échec à un moment donné car les index sont incorrects.

Utiliser un enum, c'est bien. Mais vous n'êtes pas obligé de spécifier des valeurs pour chaque élément. Il suffit de spécifier la première valeur. Je ne supposerais 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 de 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 que cela fonctionne de cette manière, vous n'avez donc pas à spécifier les valeurs.

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

En ce qui concerne le style, tout va bien.

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

Il est parfaitement normal d’utiliser une énumération pour l’indexation dans un tableau.

Vous n'avez pas besoin de spécifier chaque valeur enum, elles seront incrémentées automatiquement de 1. En laissant le compilateur choisir les valeurs, cela réduit le risque d'erreur de frappe et de création d'un bogue, mais cela vous empêche de voir les valeurs, ce qui peut être utile. en débogage.

Ça va, mais j'aimerais vérifier certaines limites du tableau, car si quelqu'un ajoute un autre ButtonState, vous aurez un problème.

De plus, les éléments du tableau de couleurs sont immuables, alors envisagez peut-être d’utiliser une collection différente pour mettre en tableau afin de pouvoir appliquer cette immutabilité. Peut-être un Dictionnaire < ButtonState, ButtonColor >

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top