Pourquoi les flag enums sont généralement définis avec des valeurs hexadécimales ?

Question

Je vois souvent des déclarations de flag enum qui utilisent des valeurs hexadécimales. Par exemple :

[Flags]
public enum MyEnum
{
    None  = 0x0,
    Flag1 = 0x1,
    Flag2 = 0x2,
    Flag3 = 0x4,
    Flag4 = 0x8,
    Flag5 = 0x10
}

Lorsque je déclare un enum, je le déclare généralement comme ceci :

[Flags]
public enum MyEnum
{
    None  = 0,
    Flag1 = 1,
    Flag2 = 2,
    Flag3 = 4,
    Flag4 = 8,
    Flag5 = 16
}

Y a-t-il une raison ou un raisonnement qui explique pourquoi certaines personnes choisissent d'écrire la valeur en hexadécimal plutôt qu'en décimal ? D'après moi, il est plus facile de s'embrouiller en utilisant des valeurs hexadécimales et d'écrire par accident Flag5 = 0x16 au lieu de Flag5 = 0x10 .

Answer 1

Les raisons peuvent être différentes, mais un avantage que je vois est que l'hexadécimal vous rappelle : "Ok, nous n'avons plus affaire à des nombres dans le monde arbitraire de la base dix inventé par l'homme. Nous avons affaire à des bits - le monde de la machine - et nous allons jouer selon ses règles." L'hexadécimal est rarement utilisé, sauf si vous traitez de sujets de relativement bas niveau où la disposition des données en mémoire a de l'importance. L'utiliser laisse entendre que c'est la situation dans laquelle nous nous trouvons actuellement.

De plus, je ne suis pas sûr pour le C#, mais je sais qu'en C x << y est une constante de temps de compilation valide. L'utilisation de décalages de bits semble la plus claire :

[Flags]
public enum MyEnum
{
    None  = 0,
    Flag1 = 1 << 0,
    Flag2 = 1 << 1,
    Flag3 = 1 << 2,
    Flag4 = 1 << 3,
    Flag5 = 1 << 4
}

Answer 2

Il est facile de voir que ce sont binaire drapeaux.

None  = 0x0,  // == 00000
Flag1 = 0x1,  // == 00001
Flag2 = 0x2,  // == 00010
Flag3 = 0x4,  // == 00100
Flag4 = 0x8,  // == 01000
Flag5 = 0x10  // == 10000

Bien que le progression le rend encore plus clair :

Flag6 = 0x20  // == 00100000
Flag7 = 0x40  // == 01000000
Flag8 = 0x80  // == 10000000

Answer 3

Je pense que c'est juste parce que la séquence est toujours 1,2,4,8 et ensuite on ajoute un 0.
Comme vous pouvez le voir :

0x1 = 1 
0x2 = 2
0x4 = 4
0x8 = 8
0x10 = 16
0x20 = 32
0x40 = 64
0x80 = 128
0x100 = 256
0x200 = 512
0x400 = 1024
0x800 = 2048

et ainsi de suite, tant que vous vous souvenez de la séquence 1-2-4-8 vous pouvez construire tous les drapeaux suivants sans avoir à vous souvenir des puissances de 2

Answer 4

Parce que [Flags] signifie que l'enum est en réalité un bitfield . Avec [Flags] vous pouvez utiliser la fonction ET bit à bit ( & ) et OR ( | ) pour combiner les drapeaux. Lorsque l'on traite des valeurs binaires comme celle-ci, il est presque toujours plus clair d'utiliser des valeurs hexadécimales. C'est la raison pour laquelle nous utilisons hexadécimal en premier lieu. Chaque caractère hexadécimal correspond à exactement un nibble (quatre bits). En décimal, cette correspondance de 1 à 4 n'est pas vraie.

Answer 5

Parce qu'il existe un moyen simple et mécanique de doubler une puissance de deux en hexagone. En décimal, c'est difficile. Il faut faire de longues multiplications dans sa tête. En hexadécimal, c'est un simple changement. Vous pouvez effectuer cela jusqu'à 1UL << 63 ce que vous ne pouvez pas faire en décimal.