blocks|key|225685|text|理由可能不同，但我看到的一个好处是，十六进制提醒你：“好吧，我们不再处理人类发明的以十为基数的任意世界中的数字。我们处理的是位--机器的世界--我们将按照它的规则行事。”十六进制很少使用，除非您正在处理数据的内存布局很重要的相对低级主题。使用它暗示了一个事实，那就是我们现在的情况。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|225686|此外，我不确定C#，但我知道在C中，x+<<+y是一个有效的编译时常量。使用位移位似乎是最清楚的：|offset|length|style|CODE|225687|[Flags]
public+enum+MyEnum
{
++++None++=+0,
++++Flag1+=+1+<<+0,++//1
++++Flag2+=+1+<<+1,++//2
++++Flag3+=+1+<<+2,++//4
++++Flag4+=+1+<<+3,++//8
++++Flag5+=+1+<<+4+++//16
}|code-block|syntax|javascript|225688|entityMap^0|0|I|6|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Rationales may differ, but an advantage I see is that hexadecimal reminds you: &quot;Okay, we're not dealing with numbers in the arbitrary human-invented world of base ten anymore. We're dealing with bits - the machine's world - and we're gonna play by its rules.&quot; Hexadecimal is rarely used unless you're dealing with relatively low-level topics where the memory layout of data matters. Using it hints at the fact that that's the situation we're in now.
Also, i'm not sure about C#, but I know that in C <code>x &lt;&lt; y</code> is a valid compile-time constant.
Using bit shifts seems the most clear:
<pre class="lang-cs prettyprint-override"><code>[Flags]
public enum MyEnum
{
 None = 0,
 Flag1 = 1 &lt;&lt; 0, //1
 Flag2 = 1 &lt;&lt; 1, //2
 Flag3 = 1 &lt;&lt; 2, //4
 Flag4 = 1 &lt;&lt; 3, //8
 Flag5 = 1 &lt;&lt; 4 //16
}
</code></pre>

blocks|key|225709|text|因为有一种机械的，简单的方法可以将十六进制中的2次方加倍。用十进制表示，这很难。它需要在你的头脑中进行长时间的乘法运算。在十六进制中，这是一个简单的更改。你可以一直执行到1UL+<<+63，这是不能用十进制数表示的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|225710|entityMap^0|2D|9|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

Because there is a mechanical, simple way to double a power-of-two in hex. In decimal, this is hard. It requires long multiplication in your head. In hex it is a simple change. You can carry this out all the way up to <code>1UL &lt;&lt; 63</code> which you can't do in decimal.

blocks|key|443889|text|因为对于人类来说，它更容易遵循标志中的比特。每个十六进制数字可以适合4位二进制。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|443890|0x0+=+0000
0x1+=+0001
0x2+=+0010
0x3+=+0011

...+and+so+on

0xF+=+1111|code-block|syntax|javascript|443891|通常，您希望您的标志不会与位重叠，最简单的方法是使用十六进制值来声明您的标志。|443892|因此，如果您需要16位的标志，您将使用4位十六进制值，这样您就可以避免错误的值：|443893|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|443894|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Because it is easier to follow for humans where the bits are in the flag. Each hexadecimal digit can fit a 4 bit binary.

<pre><code>0x0 = 0000
0x1 = 0001
0x2 = 0010
0x3 = 0011

... and so on

0xF = 1111
</code></pre>

Typically you want your flags to not overlap bits, the easiest way of doing and visualizing it is using hexadecimal values to declare your flags.

So, if you need flags with 16 bits you will use 4 digit hexadecimal values and that way you can avoid erroneous values:

<pre><code>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
</code></pre>

blocks|key|225815|text|我认为这只是因为序列总是1,2,4,8，然后加一个0。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|225816|如你所见：|225817|0x1+=+1+
0x2+=+2
0x4+=+4
0x8+=+8
0x10+=+16
0x20+=+32
0x40+=+64
0x80+=+128
0x100+=+256
0x200+=+512
0x400+=+1024
0x800+=+2048|code-block|syntax|javascript|225818|以此类推，只要您记住序列1-2-4-8，您就可以构建所有后续标志，而不必记住2的幂|225819|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I think it's just because the sequence is always 1,2,4,8 and then add a 0. 
As you can see: 

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

and so on, as long as you remember the sequence 1-2-4-8 you can build all the subsequent flags without having to remember the powers of 2

A lot of times I see flag enum declarations that use hexadecimal values. For example:

<pre class="lang-cs prettyprint-override"><code>[Flags]
public enum MyEnum
{
 None = 0x0,
 Flag1 = 0x1,
 Flag2 = 0x2,
 Flag3 = 0x4,
 Flag4 = 0x8,
 Flag5 = 0x10
}
</code></pre>

When I declare an enum, I usually declare it like this:

<pre class="lang-cs prettyprint-override"><code>[Flags]
public enum MyEnum
{
 None = 0,
 Flag1 = 1,
 Flag2 = 2,
 Flag3 = 4,
 Flag4 = 8,
 Flag5 = 16
}
</code></pre>

Is there a reason or rationale to why some people choose to write the value in hexadecimal rather than decimal? The way I see it, it's easier to get confused when using hex values and accidentally write <code>Flag5 = 0x16</code> instead of <code>Flag5 = 0x10</code>.

Why are flag enums usually defined with hexadecimal values

我经常看到使用十六进制值的标志枚举声明。例如：[Flags]public enum MyEnum{    None  = 0x0,    Flag1 = 0x1,    Flag2 = 0x2,    Flag3 = 0x4,    Flag4 = 0x8,    Flag5 = 0x10}当我声明一个枚举时，我通常这...

问为什么标志枚举通常定义为十六进制值
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么标志枚举通常定义为十六进制值EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么标志枚举通常定义为十六进制值
EN