Pourquoi quelqu’un utiliserait-il l’opérateur << dans une déclaration enum?

Cela vous permet de faire quelque chose comme ceci:

 var myEnumValue = MyEnum.open | MyEnum.close; 

sans avoir besoin de compter les valeurs de bits de multiples de 2.

(comme ça):

 public enum MyEnum { open = 1, close = 2, Maybe = 4, ........ } 

Ceci est généralement utilisé avec les champs de bits, car il est clair que le modèle est, supprime le besoin de calculer manuellement les valeurs correctes et réduit donc le risque d’erreurs

 [Flags] public enum SomeBitField { open = 1 << 0 //1 closed = 1 << 1 //2 maybe = 1 << 2 //4 other = 1 << 3 //8 ... } 

Pour éviter de taper manuellement les valeurs pour un enum Flags .

 public enum MyEnum { open = 0x01, close = 0x02, Maybe = 0x04, ........ } 

C’est pour faire un enum que vous pouvez combiner.

Ce que cela signifie efficacement, c’est ceci:

 public enum MyEnum { open = 1; close = 2; Maybe = 4; //... } 

Ceci est juste une méthode plus résistante à la création d’un enum [Flags] .

Il s’agit simplement d’une manière plus propre / plus intuitive d’écrire les bits. 1, 2, 3 est une séquence plus lisible par l’homme que 0x1, 0x2, 0x4, etc.

Beaucoup de réponses ici décrivent ce que ce mécanisme vous permet de faire, mais pas pourquoi vous voudriez l’utiliser. Voici pourquoi.

Version courte:

Cette notation permet d’interagir avec d’autres composants et de communiquer avec d’autres ingénieurs, car elle vous indique explicitement le bit défini ou défini dans un mot au lieu de masquer ces informations dans une valeur numérique.

Donc, je pourrais vous appeler au téléphone et dire “Hey, quel peu pour ouvrir le fichier?” Et vous diriez “Bit 0”. Et j’écrirais dans mon code open = 1 << 0 . Parce que le numéro à droite de << vous indique le numéro de bit.

.

Version longue:

Traditionnellement, les bits d'un mot sont numérotés de droite à gauche, en commençant à zéro. Donc, le bit le moins significatif est le bit numéro 0 et vous comptez au fur et à mesure que vous avancez vers le bit le plus significatif. L'étiquetage des bits présente plusieurs avantages .

Un avantage est que vous pouvez parler du même bit quelle que soit la taille du mot. Par exemple, je pourrais dire que dans le mot de 32 bits 0x384A et le mot de 8 bits 0x63, les bits 6 et 1 sont définis. Si vous numérotiez vos bits dans l'autre direction, vous ne pourriez pas le faire.

Un autre avantage est que la valeur d'un bit est simplement scope à la puissance de la position du bit. Par exemple, le binary 0101 contient les bits 2 et 0. Le bit 2 apporte la valeur 4 (2^2) au nombre et le bit 0 la valeur 1 (2 ^ 0). Donc, la valeur du numéro est bien sûr 4 + 1 = 5.

Cette explication d'arrière-plan longue nous amène au point: la notation << vous indique le nombre de bits simplement en le regardant.

Le nombre 1 en lui-même dans la déclaration 1 << n est simplement un seul bit défini à la position de bit 0. Lorsque vous déplacez ce nombre vers la gauche, vous déplacez ensuite ce bit à une position différente du nombre. Idéalement, le montant que vous déplacez vous indique le numéro de bit qui sera défini.

 1 << 5: This means bit 5. The value is 0x20. 1 << 12: This means bit 12. The value is 0x40000. 1 << 17: This means bit 17. The value is 0x1000000. 1 << 54: This means bit 54. The value is 0x40000000000000. (You can probably see that this notation might be helpful if you're defining bits in a 64-bit number) 

Cette notation est très utile lorsque vous interagissez avec un autre composant, comme le mappage de bits dans un mot vers un registre matériel. Comme vous pourriez avoir un périphérique qui s'allume lorsque vous écrivez sur le bit 7. L'ingénieur du matériel écrirait une feuille de données indiquant que le bit 7 active le périphérique. Et vous écrivez dans votre code ENABLE = 1 << 7 . Facile comme ça.

Oh tirer L'ingénieur vient d'envoyer un errata à la fiche technique en disant qu'il était censé être le bit 15, pas le bit 7. OK, changez simplement le code en ENABLE = 1 << 15 .

Que faire si ENABLE était en réalité lorsque les deux bits 7 et 1 étaient définis simultanément?

ENABLE = (1 << 7) | (1 << 1) ENABLE = (1 << 7) | (1 << 1) .

Cela peut sembler étrange et obtus au début, mais vous vous y habituerez. Et vous apprécierez si vous avez besoin explicitement de connaître le nombre de bits de quelque chose.

Il est égal à des puissances de deux.

 public enum SomeEnum { Enum1 = 1 << 0, //1 Enum2 = 1 << 1, //2 Enum3 = 1 << 2, //4 Enum4 = 1 << 3 //8 } 

Et avec un tel enum vous aurez une fonction qui ressemble à ceci:

 void foo(unsigned ind flags) { for (int = 0; i < MAX_NUMS; i++) if (1 << i & flags) { //do some stuff... //parameter to that stuff probably is i either enum value } } 

Et appeler à cette fonction serait foo(Enum2 | Enum3); et cela fera quelque chose avec toutes les valeurs enum données.