Почему перечисления флагов обычно определяются с шестнадцатеричными значениями

Я часто вижу объявления перечисления флагов, в которых используются шестнадцатеричные значения. Например:

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

Когда я объявляю перечисление, я обычно объявляю его так:

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

Есть ли причина или объяснение, почему некоторые люди предпочитают записывать значение в шестнадцатеричном, а не в десятичном формате? На мой взгляд, проще запутаться при использовании шестнадцатеричных значений и случайно написать Flag5 = 0x16вместо Flag5 = 0x10.

Обоснования могут быть разными, но я вижу преимущество в том, что шестнадцатеричное число напоминает вам: «Хорошо, мы больше не имеем дело с числами в произвольном изобретенном людьми мире десятичной системы. Мы имеем дело с битами - миром машин - и мы поиграем по ее правилам ". Шестнадцатеричный формат используется редко, если только вы не имеете дело с относительно низкоуровневыми темами, в которых структура памяти данных имеет значение. Его использование намекает на то, что мы сейчас в такой ситуации.

Кроме того, я не уверен насчет C #, но я знаю, что в C x << y- допустимая константа времени компиляции. Наиболее очевидным кажется использование битовых сдвигов:

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

Это позволяет легко увидеть, что это бинарные флаги.

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

Хотя прогрессия делает это еще яснее:

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

Я думаю, это просто потому, что последовательность всегда 1, 2, 4, 8, а затем добавляется 0.
Как видите:

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

и так далее, если вы помните последовательность 1-2-4-8, вы можете построить все последующие флаги, не запоминая степени двойки.

Потому [Flags]что означает, что перечисление действительно является битовым полем . С [Flags]вы можете использовать побитовое И ( &) и OR ( |) операторы , чтобы объединить флаги. При работе с такими двоичными значениями почти всегда проще использовать шестнадцатеричные значения. Именно по этой причине мы в первую очередь используем шестнадцатеричные числа. Каждому шестнадцатеричному символу соответствует ровно один полубайт (четыре бита). С десятичным числом это преобразование 1 в 4 не выполняется.

Потому что существует механический и простой способ удвоить степень двойки в шестнадцатеричной системе. В десятичном выражении это сложно. Это требует длительного умножения в голове. В шестнадцатеричном формате это простое изменение. Вы можете выполнять это полностью, 1UL << 63но не можете использовать десятичные дроби.

Потому что людям легче следить за тем, где биты находятся во флаге. Каждая шестнадцатеричная цифра может соответствовать 4-битной двоичной системе.

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

... and so on

0xF = 1111

Обычно вы хотите, чтобы ваши флаги не перекрывали биты, самый простой способ сделать и визуализировать это - использовать шестнадцатеричные значения для объявления ваших флагов.

Итак, если вам нужны 16-битные флаги, вы будете использовать 4-значные шестнадцатеричные значения, и таким образом вы сможете избежать ошибочных значений:

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