Pourquoi les énumérations d'indicateurs sont généralement définies avec des valeurs hexadécimales

Souvent, je vois des déclarations d'énumération de drapeau 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 une énumération, je la 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 une justification pour laquelle certaines personnes choisissent d'écrire la valeur en hexadécimal plutôt qu'en décimal? À mon avis, il est plus facile de se tromper lors de l'utilisation de valeurs hexadécimales et d'écrire accidentellement à la Flag5 = 0x16place de Flag5 = 0x10.

Les raisonnements peuvent différer, mais un avantage que je vois est que l'hexadécimal vous rappelle: "D'accord, nous n'avons plus affaire à des nombres dans le monde arbitraire inventé par l'homme de la base dix. Nous avons affaire à des bits - le monde de la machine - et nous va jouer selon ses règles. " L'hexadécimal est rarement utilisé, sauf si vous avez affaire à des sujets de niveau relativement bas où la disposition de la mémoire des données est importante. Son utilisation laisse entendre que c'est la situation dans laquelle nous nous trouvons actuellement.

De plus, je ne suis pas sûr de C #, mais je sais qu'en C x << yest une constante de compilation valide. L'utilisation des 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
}

Cela permet de voir facilement que ce sont des indicateurs binaires .

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

Bien que la progression le rend encore plus clair:

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

Je pense que c'est juste parce que la séquence est toujours 1, 2, 4, 8 et ensuite ajouter 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 pouvoirs de 2

Parce [Flags]que cela signifie que l'énumération est vraiment un bitfield . Avec, [Flags]vous pouvez utiliser les opérateurs binaires AND ( &) et OR ( |) pour combiner les indicateurs. Lorsqu'il s'agit de valeurs binaires comme celle-ci, il est presque toujours plus clair d'utiliser des valeurs hexadécimales. C'est la raison même pour laquelle nous utilisons l' hexadécimal en premier lieu. Chaque caractère hexadécimal correspond à exactement un quartet (quatre bits). Avec décimal, ce mappage 1 à 4 n'est pas vrai.

Parce qu'il existe un moyen mécanique et simple de doubler une puissance de deux dans l'hexagone. En décimal, c'est difficile. Cela nécessite une longue multiplication dans votre tête. En hexadécimal, c'est un simple changement. Vous pouvez effectuer cela jusqu'au bout, 1UL << 63ce que vous ne pouvez pas faire en décimal.

Parce qu'il est plus facile à suivre pour les humains où les bits sont dans le drapeau. Chaque chiffre hexadécimal peut contenir un binaire de 4 bits.

0x0 = 0000
0x1 = 0001
0x2 = 0010
0x3 = 0011

... and so on

0xF = 1111

En général, vous voulez que vos indicateurs ne chevauchent pas les bits, le moyen le plus simple de le faire et de le visualiser consiste à utiliser des valeurs hexadécimales pour déclarer vos indicateurs.

Donc, si vous avez besoin de drapeaux de 16 bits, vous utiliserez des valeurs hexadécimales à 4 chiffres et vous éviterez ainsi les valeurs erronées:

0x0001 //= 1 = 000000000000 0001
0x0002 //= 2 = 000000000000 0010
0x0004 //= 4 = 000000000000 0100
0x0008 //= 8 = 000000000000 1000
...
0x0010 //= 16 = 0000 0000 0001 0000
0x0020 //= 32 = 0000 0000 0010 0000
...
0x8000 //= 32768 = 1000 0000 0000 0000