Que signifie cette énumération?

On dirait qu’il définit un type énuméré censé contenir un ensemble d’indicateurs. Vous vous attendez à en voir plus, comme ceci:

 typedef enum { FirstOption = 1 << 0, SecondOption = 1 << 1, ThirdOption = 1 << 2 } SomeOption; 

Comme elles sont définies comme des puissances de deux, chaque valeur correspond à un seul bit dans une variable entière. Ainsi, vous pouvez utiliser les opérateurs au niveau du bit pour les combiner et pour tester s’ils sont définis. Ceci est un modèle commun dans le code C.

Vous pourriez écrire un code comme celui-ci qui les combine:

 SomeOption myOptions = FirstOption | ThirdOption; 

Et vous pouvez vérifier quelles options sont définies comme ceci:

 if (myOptions & ThirdOption) { ... } 

SomeOptionKeys une, c’est une représentation utile lorsque vous SomeOptionKeys indicateurs:

 typedef enum { flag1 = 1 << 0, // binary 00000000000000000000000000000001 flag2 = 1 << 1, // binary 00000000000000000000000000000010 flag3 = 1 << 2, // binary 00000000000000000000000000000100 flag4 = 1 << 3, // binary 00000000000000000000000000001000 flag5 = 1 << 4, // binary 00000000000000000000000000010000 // ... } SomeOption; 

Ainsi, chaque drapeau n'a qu'un seul jeu de bits, et ils pourraient être représentés dans un bitmap.

Modifier:

Bien que, je dois dire, il se peut que je manque quelque chose, mais il me semble redondant d’utiliser des énumérations pour cela. Puisque vous perdez tout avantage des énumérations dans cette configuration, vous pouvez également utiliser #define :

 #define flag1 (1<<0) #define flag2 (1<<1) #define flag3 (1<<2) #define flag4 (1<<3) #define flag5 (1<<4) 

Il ne fait que définir l’énumération sur 1. Il est probablement destiné à indiquer que les valeurs doivent être des puissances de 2. On atsortingbuerait peut-être la suivante à 1 << 1 , etc.

<< est l'opérateur de décalage à gauche. En général, ceci est utilisé lorsque vous voulez que vos enums masquent un seul bit. Dans ce cas, le décalage ne fait rien puisqu'il s'agit de 0, mais vous pouvez le voir apparaître dans des cas plus complexes.

Un exemple pourrait ressembler à ceci:

 typedef enum { OptionKeyA = 1<<0, OptionKeyB = 1<<1, OptionKeyC = 1<<2, } OptionKeys; 

Ensuite, si vous avez une fonction qui prend une clé d’option, vous pouvez utiliser l’énumération comme masque de bits pour vérifier si une option est définie.

 int ASet( OptionKeys x){ return (x & OptionKeyA); } 

Ou si vous aviez un bitmap de drapeau et vouliez définir une option:

 myflags | OptionKeyB