Tại sao cờ enums thường được xác định bằng các giá trị thập lục phân

Rất nhiều lần tôi thấy các khai báo cờ enum sử dụng các giá trị thập lục phân. Ví dụ:

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

Khi tôi khai báo một enum, tôi thường khai báo nó như thế này:

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

Có lý do hoặc cơ sở nào giải thích tại sao một số người chọn viết giá trị dưới dạng thập lục phân thay vì thập phân? Theo cách tôi thấy, nó dễ bị nhầm lẫn hơn khi sử dụng các giá trị hex và vô tình viết Flag5 = 0x16thay vì Flag5 = 0x10.

Các luận điểm có thể khác nhau, nhưng một lợi thế mà tôi thấy là hệ thập lục phân nhắc nhở bạn: "Được rồi, chúng tôi không xử lý các con số trong thế giới tùy ý do con người phát minh ra của cơ số 10 nữa. Chúng tôi đang xử lý các bit - thế giới của máy móc - và chúng tôi sẽ chơi theo luật của nó. " Hệ thập lục phân hiếm khi được sử dụng trừ khi bạn đang xử lý các chủ đề cấp tương đối thấp trong đó bố cục bộ nhớ của dữ liệu quan trọng. Sử dụng nó gợi ý thực tế rằng đó là tình huống chúng ta đang ở hiện tại.

Ngoài ra, tôi không chắc về C #, nhưng tôi biết rằng trong C x << ylà một hằng số thời gian biên dịch hợp lệ. Sử dụng dịch chuyển bit có vẻ rõ ràng nhất:

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

Dễ dàng nhận thấy đây là các cờ nhị phân .

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

Mặc dù tiến trình làm cho nó thậm chí còn rõ ràng hơn:

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

Tôi nghĩ đó chỉ là vì dãy luôn là 1,2,4,8 và sau đó thêm 0.
Như bạn có thể thấy:

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

v.v.

Vì [Flags]có nghĩa là enum thực sự là một bitfield . Với [Flags]bạn có thể sử dụng toán tử bitwise AND ( &) và OR ( |) để kết hợp các cờ. Khi xử lý các giá trị nhị phân như thế này, hầu như luôn rõ ràng hơn khi sử dụng các giá trị thập lục phân. Đây là lý do chúng tôi sử dụng hệ thập lục phân ngay từ đầu. Mỗi ký tự hex tương ứng với chính xác một nibble (bốn bit). Với số thập phân, ánh xạ 1 đến 4 này không đúng.

Bởi vì có một cách cơ học, đơn giản để nhân đôi lũy thừa của hai trong hệ lục phân. Trong số thập phân, điều này là khó. Nó đòi hỏi sự nhân lên lâu dài trong đầu bạn. Trong hex, đó là một thay đổi đơn giản. Bạn có thể thực hiện điều này theo mọi cách 1UL << 63mà bạn không thể thực hiện trong hệ thập phân.

Bởi vì nó dễ dàng hơn để theo dõi đối với con người nơi các bit trong cờ. Mỗi chữ số thập lục phân có thể phù hợp với một nhị phân 4 bit.

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

... and so on

0xF = 1111

Thông thường, bạn muốn cờ của mình không chồng chéo các bit, cách dễ nhất để thực hiện và hình dung nó là sử dụng các giá trị thập lục phân để khai báo cờ của bạn.

Vì vậy, nếu bạn cần cờ có 16 bit, bạn sẽ sử dụng các giá trị thập lục phân 4 chữ số và bằng cách đó, bạn có thể tránh các giá trị sai:

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