À l’aide de Types énumérés comme Bitflags (1 / 3 étapes)

Étape 1: contexte

L’utilisation de bits indicateurs remonte passant loin aux premiers jours de programmation C. L’idée est vraiment très simple. La valeur au lieu d’utiliser un entier du singulier comme une valeur booléenne (true ou false ou un ou zéro), vous pouvez utiliser chacun des bits à l’intérieur de l’entier comme un drapeau eux-mêmes. Cela ne fonctionne que si vos drapeaux est des valeurs booléennes naturellement, mais heureusement, dans la programmation autant de fois qu’ils sont.

Par exemple, nous pourrions déclarer un entier 8 bits comme un drapeau pour afficher quelques instructions ou non ou non :

unsigned char DISPLAY_INSTRUCTIONS = 1;

En utilisant une valeur 8 bits nous permettrait d’avoir 2 valeurs possibles⁸ ou 256 drapeaux unique. Chaque drapeau prendrait un octet des ressources, sur disque ou en core RAM. Nous pourrions également utiliser les autres valeurs standard pour le drapeau comme uint16_t, une valeur de 16 bits stocker jusqu'à 65 535 drapeaux unique, probablement beaucoup plus que nous aurions besoin ou jamais utiliser. Mais que se passe-t-il si nous n’avions, disons, 6 drapeaux nous devions suivre ? Dans le schéma ci-dessus, il faudrait six octets, un octet pour chaque indicateur, mais à l’aide de bits indicateurs nous pourrions stocker tous les six flags (et puis certains) à l’intérieur d’un seul octet.

Si vous n’êtes pas familier avec les nombres binaires, vous pourriez prendre un moment et lire mon instructable sur bases de numéro, qui inclut le fichier binaire ou de trouver un certain nombre de tutoriels en ligne. Je supposerai que vous avez déjà un passage compréhension des nombres binaires comment sont mis en place. Donc, vous demandez peut-être comment un utilise-t-il les bits individuels à l’intérieur d’un nombre entier comme un drapeau devant pour servir à code/logiciel ? En général, cela se fait en assignant un peu à « 1 » ou « 0 » et basée sur son positionnement à l’intérieur de l’entier, peut être utilisé pour une affirmation ou une négation de la valeur spécifiée. Par exemple, prendre un 8-bit n, disons, zéro et regardez-le.

0000 0000

OK, rien d’excitant ici. Maintenant à l’emplacement de la 1, faire 1 :

0000 0000

Nous pouvons faire la même chose pour les deux emplacement :

0000 0010

ou l’emplacement de quatre :

0000 0100

ou peut-être le 32 et 8ème emplacement :
0010 1000

Quels numéros font ces flips bit ? On s’en fout. Nous sommes uniquement préoccupés par les bits individuels à l’intérieur le nombre dans ce cas. Pour facilement affecter des valeurs d’indicateur à bits, il est courant d’utiliser le langage suivant :

#define FLAG1 0x01 // 0000 0001
#define FLAG2 0x02 // #define FLAG1 0x01 // 0000 0001
 #define FLAG2 0x02 // 0000 0010
 #define FLAG3 0x04 // 0000 0100
 #define FLAG4 0x08 // 0000 1000
 #define FLAG5 0x10 // 0001 0000
 #define FLAG6 0x20 // 0010 0000
 #define FLAG7 0x40 // 0100 0000
 #define FLAG8 0x80 // 1000 0000
#define FLAG3 0x04 // unsigned char myFlags = 0x00; myFlags |= FLAG5;
#define FLAG4 0x08 // 0000 1000
#define FLAG5 0x10 // 0001 0000
#define FLAG6 0x20 // 0010 0000
#define FLAG7 0x40 // 0100 0000
#define FLAG8 0x80 // 1000 0000

Là, nous avons défini nos drapeaux. Prenez note du patron en nombre hexadécimal et sa représentation binaire. Donc, si Indicateur5 est défini, puis le drapeau entier serait ont bit 5 défini (à l’aide d’un index de base 1, à l’encontre le plus commun basé sur 0, mais il n’est pas important pour nous maintenant). Créer la variable d’indicateur et paramétrer Indicateur5 ressemble à ceci :

myFlags &= ~FLAG3;

Nous ou les drapeaux afin que tous les indicateurs existants resteront conservés. Si vous et les drapeaux, vous allez écrire sur tous les indicateurs existants avec le masque de bits votre ANDing lui. Ceci est utile lorsque vous souhaitez désactiver un indicateur :

#define FLAG28 0x00400000

Les ensembles ci-dessus Indicateur3 à zéro. Notez que vous êtes associé avec le complément du drapeau.
Mais que se passe-t-il si vous avez :

#define FLAG_1 0x01
 #define FLAG_2 0x02
 #define FLAG_3 0x04
 #define FLAG_4 0x08
 ...
 uint32_t _flags;
 // set a flag
 _flags |= FLAG_2;
 // clear a flag
 _flags &= ~FLAG_3;
 // test bit flag
 if (_flags & FLAG_4)
 do_something();

et vous essayez de la définir avec notre entier de 8 bits ? Vous aurez un dépassement de capacité avec les tailles ne correspondent pas entier et obtenez une erreur, probablement lors de l’exécution et compile pas temps parce que le compilateur sera généralement promouvoir ou sinon convertit implicitement votre drapeau constant en le type qui est exploité. Ce n’est pas toujours le cas, mais c’est souvent. Cela peut créer des difficile à attraper des bogues et la pire espèce : DUREE bogues. Ils sont mauvais parce qu’ils peuvent être plus difficiles à traquer, plus difficile à reproduire et introduite à vos utilisateurs, qui vous voulez jamais faire autant que possible.

En outre, que si vous aviez besoin d’un nouveau drapeau, Indicateur9 dire, mais avec la valeur 0x0080 pour une raison quelconque ? Vous auriez à 1) étendre votre drapeau tapez pour accueillir la plus grande taille et 2) insérer le drapeau dans vos déclarations de drapeau et renuméroter tous les drapeaux derrière elle. Ce n’est pas faisable et certainement pas facile à gérer.

Que faites-vous sur ces problèmes ? Comment pouvons-nous garantir sécurité de type et de l’extensibilité à nos drapeaux ? Tourner la page et découvrez !