blocks|key|3131899|text|因为十六进制(很少是八进制)的文字更紧凑，而且使用它们的人通常可以比解密二进制数更快地在十六进制和二进制之间进行转换。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3131900|Python+2.6%2B允许使用二进制文字，Ruby和Java+7也是如此，您可以使用下划线使字节边界变得明显。例如，十六进制值0x1b2a现在可以写为0b00011011_00101010。|offset|length|style|CODE|3131901|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/reference/lexical_analysis.html#integer-and-long-integer-literals|1|http://blogs.oracle.com/darcy/entry/project_coin_literal_grammar_hackery^0|0|1R|6|23|J|0|B|0|Q|6|1|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@$D|T|E|U|F|G]|$D|V|E|W|F|G]]|9|@$D|X|E|Y|1|Z]|$D|10|E|11|1|12]]|A|$]]|$1|H|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]|P|$5|K|L|M|A|$N|Q]]]]

Because hexadecimal (and rarely octal) literals are more compact and people using them usually can convert between hexadecimal and binary faster than deciphering a binary number.

<a href="http://docs.python.org/reference/lexical_analysis.html#integer-and-long-integer-literals" rel="nofollow noreferrer">Python 2.6+</a> allows binary literals, and so do Ruby and <a href="http://blogs.oracle.com/darcy/entry/project_coin_literal_grammar_hackery" rel="nofollow noreferrer">Java 7</a>, where you can use the underscore to make byte boundaries obvious. For example, the hexadedecimal value <code>0x1b2a</code> can now be written as <code>0b00011011_00101010</code>.

blocks|key|3344718|text|在支持user+defined+literals二进制数的C%2B%2B0x中，我不确定它是否会成为标准的一部分，但在最坏的情况下，您可以自己启用它|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3344719|int+operator+""+_B(int+i);

assert(+1010_B+==+10);|code-block|syntax|javascript|3344720|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/C%252B%252B0x#User-defined_literals^0|3|L|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

In C++0x with <a href="http://en.wikipedia.org/wiki/C%2B%2B0x#User-defined_literals" rel="nofollow noreferrer">user defined literals</a> binary numbers will be supported, I'm not sure if it will be part of the standard but at the worst you'll be able to enable it yourself

<pre><code>int operator "" _B(int i);

assert( 1010_B == 10);
</code></pre>

blocks|key|351063|text|为了使位表示有意义，您需要知道如何解释它。您需要指定使用的二进制数的类型(有符号/无符号、二进制-互补、一-互补、有符号幅度)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|351064|我使用过的唯一能正确支持二进制数的语言是硬件描述语言(Verilog、VHDL等)。对于如何处理以二进制形式输入的数字，它们都有严格的(并且常常令人困惑的)定义。|351065|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

In order for a bit representation to be meaningful, you need to know how to interpret it.
You would need to specify what the type of binary number you're using (signed/unsigned, twos-compliment, ones-compliment, signed-magnitude).

The only languages I've ever used that properly support binary numbers are hardware description languages (Verilog, VHDL, and the like). They all have strict (and often confusing) definitions of how numbers entered in binary are treated.

blocks|key|3344903|text|请参阅perldoc+perlnumber|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3344904|NAME
+++perlnumber+-+semantics+of+numbers+and+numeric+operations+in+Perl

SYNOPSIS
+++++++$n+=+1234;++++++++++++++#+decimal+integer
+++++++$n+=+0b1110011;+++++++++#+binary+integer
+++++++$n+=+01234;+++++++++++++#+octal+integer
+++++++$n+=+0x1234;++++++++++++#+hexadecimal+integer
+++++++$n+=+12.34e-56;+++++++++#+exponential+notation
+++++++$n+=+"-12.34e56";+++++++#+number+specified+as+a+string
+++++++$n+=+"1234";++++++++++++#+number+specified+as+a+string|code-block|syntax|javascript|3344905|entityMap|0|LINK|mutability|MUTABLE|url|http://perldoc.perl.org/perlnumber.html#SYNOPSIS^0|3|I|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

See <a href="http://perldoc.perl.org/perlnumber.html#SYNOPSIS" rel="nofollow noreferrer">perldoc perlnumber</a>:

<pre><code>NAME
 perlnumber - semantics of numbers and numeric operations in Perl

SYNOPSIS
 $n = 1234; # decimal integer
 $n = 0b1110011; # binary integer
 $n = 01234; # octal integer
 $n = 0x1234; # hexadecimal integer
 $n = 12.34e-56; # exponential notation
 $n = "-12.34e56"; # number specified as a string
 $n = "1234"; # number specified as a string
</code></pre>

blocks|key|354831|text|有点离题，但较新版本的GCC增加了一个允许二进制文字的C扩展。所以，如果你只用GCC编译，你可以使用它们。文档化是here。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|354832|entityMap|0|LINK|mutability|MUTABLE|url|http://gcc.gnu.org/onlinedocs/gcc-4.3.3/gcc/Binary-constants.html#Binary-constants^0|1L|4|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Slightly off-topic, but newer versions of GCC added a C extension that allows binary literals. So if you only ever compile with GCC, you can use them. Documenation is <a href="http://gcc.gnu.org/onlinedocs/gcc-4.3.3/gcc/Binary-constants.html#Binary-constants" rel="nofollow noreferrer">here</a>.

blocks|key|354685|text|Common+Lisp允许二进制数，使用#b...(从2的最高到最低幂的位数)。大多数情况下，使用十六进制数字至少一样方便(通过使用#x...)，因为在您的头脑中在十六进制和二进制数之间进行转换相当容易。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|354686|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Common Lisp allows binary numbers, using #b... (bits going from highest-to-lowest power of 2). Most of the time, it's at least as convenient to use hexadecimal numbers, though (by using #x...), as it's fairly easy to convert between hexadecimal and binary numbers in your head.

blocks|key|354663|text|十六进制和八进制只是编写二进制的较短方式。您真的希望在代码中定义一个64个字符的长常量吗？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|354664|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Hex and octal are just shorter ways to write binary. Would you really want a 64-character long constant defined in your code?

blocks|key|350999|text|常识认为，长串的二进制数字，例如32位的整数，对人们来说太难解析和操作了。十六进制通常被认为是更容易的，尽管我还没有用到足够多的东西来培养自己的偏好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|351000|Ruby，如前所述，试图通过允许在文字中自由插入_来解决这个问题，例如：|351001|irb(main):005:0>+1111_0111_1111_1111_0011_1100
=>+111101111111111100111100|code-block|syntax|javascript|351002|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Common wisdom holds that long strings of binary digits, eg 32 bits for an int, are too difficult for people to conveniently parse and manipulate. Hex is generally considered easier, though I've not used either enough to have developed a preference.

Ruby which, as already mentioned, attempts to resolve this by allowing _ to be liberally inserted in the literal , allowing, for example:

<pre><code>irb(main):005:0&gt; 1111_0111_1111_1111_0011_1100
=&gt; 111101111111111100111100
</code></pre>

blocks|key|3131994|text|D支持使用语法0bB%2B的二进制文字，例如0b1001。它还允许在数字文字中嵌入_+characters，以便更容易地读取它们。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3131995|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

D supports binary literals using the syntax 0[bB][01]+, e.g. 0b1001. It also allows embedded _ characters in numeric literals to allow them to be read more easily.

blocks|key|352301|text|Java+7现在支持二进制文字。所以你可以简单地写成0b110101。关于此功能的文档并不多。我能找到的唯一参考资料是here。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|352302|entityMap|0|LINK|mutability|MUTABLE|url|http://mail.openjdk.java.net/pipermail/coin-dev/2009-April/001627.html^0|1N|4|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Java 7 now has support for binary literals. So you can simply write 0b110101. There is not much documentation on this feature. The only reference I could find is <a href="http://mail.openjdk.java.net/pipermail/coin-dev/2009-April/001627.html" rel="nofollow noreferrer">here</a>.

blocks|key|3132250|text|虽然C语言只支持8、10或16作为基数，但实际上编写一个预处理器宏并不难，它使得写入8位二进制数变得非常简单和可读：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3132251|#define+BIN(d7,d6,d5,d4,+d3,d2,d1,d0)++++++++++++++++++++++\
(++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\
++++((d7)<<7)+%2B+((d6)<<6)+%2B+((d5)<<5)+%2B+((d4)<<4)+%2B++++++++\
++++((d3)<<3)+%2B+((d2)<<2)+%2B+((d1)<<1)+%2B+((d0)<<0)++++++++++\
)
int+my_mask+=+BIN(1,1,1,0,+0,0,0,0);|code-block|syntax|javascript|3132252|这也可以用于C%2B%2B。|3132253|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

While C only have native support for 8, 10 or 16 as base, it is actually not that hard to write a pre-processor macro that makes writing 8 bit binary numbers quite simple and readable:

<pre><code>#define BIN(d7,d6,d5,d4, d3,d2,d1,d0) \
( \
 ((d7)&lt;&lt;7) + ((d6)&lt;&lt;6) + ((d5)&lt;&lt;5) + ((d4)&lt;&lt;4) + \
 ((d3)&lt;&lt;3) + ((d2)&lt;&lt;2) + ((d1)&lt;&lt;1) + ((d0)&lt;&lt;0) \
)
int my_mask = BIN(1,1,1,0, 0,0,0,0);
</code></pre>

This can also be used for C++.

blocks|key|3344832|text|为了记录，并回答这个问题：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3344833|3344834|加分！...哪些语言允许二进制数？|blockquote|3344835|3344836|3344837|Specman+(也称为e)允许使用二进制数。尽管老实说，它不是一种通用的语言。|3344838|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|M|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|N|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|O|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|P|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|Q|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|K|$]]

for the record, and to answer this:

<blockquote>
 Bonus Points!... What languages do allow binary numbers?
</blockquote>

Specman (aka e) allows binary numbers. Though to be honest, it's not quite a general purpose language.

blocks|key|3345124|text|每种语言都应该支持二进制文字。没有它们我都快疯了！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3345125|3345126|加分！...哪些语言允许二进制数？|blockquote|3345127|3345128|3345129|Icon允许从2到16的任意基数的文字，最多可以到36+(我的记忆力变得模糊)。|offset|length|3345130|entityMap|0|LINK|mutability|MUTABLE|url|http://www.cs.arizona.edu/icon/^0|0|0|0|0|0|0|4|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|U|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|V|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|W|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|X|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|Y|8|@]|9|@$J|Z|K|10|1|11]]|A|$]]|$1|L|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|M|$N|$5|O|P|Q|A|$R|S]]]]

Every language should support binary literals. I go nuts not having them!

<blockquote>
 Bonus Points!... What languages do allow binary numbers?
</blockquote>

<a href="http://www.cs.arizona.edu/icon/" rel="nofollow noreferrer">Icon</a> allows literals in any base from 2 to 16, and possibly up to 36 (my memory grows dim).

blocks|key|351029|text|从可读性和可用性的角度来看，十六进制表示法似乎是定义二进制数的更好方法。他们没有添加它的事实可能更多的是用户需求，而不是技术限制。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|351030|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

It seems the from a readability and usability standpoint, the hex representation is a better way of defining binary numbers. The fact that they don't add it is probably more of user need that a technology limitation.

blocks|key|3132044|text|我想语言设计者只是没有意识到添加二进制数的必要性。在处理标志或位掩码时，一般的编码器可以像解析二进制一样解析十六进制。一些语言支持二进制表示，这很好，但我认为平均来说，它很少被使用。尽管二进制--如果在C、C%2B%2B、Java、C#中可用，可能会比八进制使用得更多！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3132045|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I expect that the language designers just didn't see enough of a need to add binary numbers. The average coder can parse hex just as well as binary when handling flags or bit masks. It's great that some languages support binary as a representation, but I think on average it would be little used. Although binary -- if available in C, C++, Java, C#, would probably be used more than octal!

blocks|key|349799|text|在Smalltalk中，它类似于2r1010。您可以使用任何基地，直到36左右。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|349800|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

In Smalltalk it's like 2r1010. You can use any base up to 36 or so.

blocks|key|349805|text|十六进制只是不那么冗长，可以表达二进制数可以表达的任何东西。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|349806|Ruby对二进制数有很好的支持，如果你真的想要的话。0b11011等。|349807|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Hex is just less verbose, and can express anything a binary number can.

Ruby has nice support for binary numbers, if you really want it. 0b11011, etc.

blocks|key|354840|text|在Pop-11中，您可以使用由数字(2到32)+%2B冒号组成的前缀来表示基数，例如|type|unstyled|depth|inlineStyleRanges|entityRanges|data|354841|2:11111111+=+255|354842|3:11111111+=+3280|354843|16:11111111+=+286331153|354844|31:11111111+=+28429701248|354845|32:11111111+=+35468117025|354846|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Q|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|M|$]]

In Pop-11 you can use a prefix made of number (2 to 32) + colon to indicate the base, e.g.

2:11111111 = 255

3:11111111 = 3280

16:11111111 = 286331153

31:11111111 = 28429701248

32:11111111 = 35468117025

blocks|key|352282|text|虽然不是直接的，但大多数语言也可以解析字符串。Java可以通过一个方法将"10101000“转换为int类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|352283|并不是说这是有效的或者别的什么.只是说它就在那里。如果它是在静态初始化块中完成的，那么它甚至可能在编译时完成，这取决于编译器。|352284|如果你擅长二进制，即使是一个很短的数字，也很容易看到0x3c是4个1后面跟着2个0，而即使是这么短的二进制数字也是0b111100，这可能会在你确定1的数量之前让你的眼睛受伤。|352285|0xff9f恰好是4%2B4%2B1+1，2个0和5个1(看起来位掩码很明显)。尝试计数0b1111111110011111更令人恼火。|352286|我认为问题可能是语言设计者总是在十六进制/八进制/二进制/任何东西上投入大量资金，并以这种方式思考。如果你经验较少，我可以完全理解这些转换是如何不明显的。|352287|嘿，这让我想起了我在思考基数转换时想到的一些东西。一个序列--我认为没有人能计算出“下一个数字”，但实际上有一个人做到了，所以它是可以解决的。试一试：|352288|10
11
12
13
14
15
16
21
23
31
111
?|code-block|syntax|javascript|352289|编辑:顺便说一句，在大多数语言(肯定是Java)中，这个序列可以通过将序列号提供给单个内置函数来创建。|352290|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|X|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|Y|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|Z|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|10|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

Although it's not direct, most languages can also parse a string. Java can convert &quot;10101000&quot; into an int with a method.
Not that this is efficient or anything... Just saying it's there. If it were done in a static initialization block, it might even be done at compile time depending on the compiler.
If you're any good at binary, even with a short number it's pretty straight forward to see 0x3c as 4 ones followed by 2 zeros, whereas even that short a number in binary would be 0b111100 which might make your eyes hurt before you were certain of the number of ones.
0xff9f is exactly 4+4+1 ones, 2 zeros and 5 ones (on sight the bitmask is obvious). Trying to count out 0b1111111110011111 is much more irritating.
I think the issue may be that language designers are always heavily invested in hex/octal/binary/whatever and just think this way. If you are less experienced, I can totally see how these conversions wouldn't be as obvious.
Hey, that reminds me of something I came up with while thinking about base conversions. A sequence--I didn't think anyone could figure out the &quot;Next Number&quot;, but one guy actually did, so it is solvable. Give it a try:
<pre><code>10
11
12
13
14
15
16
21
23
31
111
?
</code></pre>
Edit:
By the way, this sequence can be created by feeding sequential numbers into single built-in function in most languages (Java for sure).

blocks|key|3345211|text|Forth总是允许使用任意数量的基数(当然是CPU的大小限制)。想要使用二进制：2+BASE+!，八进制：8+BASE+!等。想使用时间吗？60+BASE+!这些例子都是从基数到十进制输入的。要更改基数，必须表示当前数字基数所需的基数。如果是二进制，并且您想要切换回十进制，那么1010+BASE+!将起作用。大多数Forth实现都有“单词”可以转移到公共基础上，例如DECIMAL、HEX、OCTAL和BINARY。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3345212|entityMap^0|14|8|1H|8|1Y|9|3V|B|54|7|5C|3|5G|5|5M|6|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|G|$]]

Forth has always allowed numbers of any base to be used (up to size limit of the CPU of course). Want to use binary: <code>2 BASE !</code> octal: <code>8 BASE !</code> etc. Want to work with time? <code>60 BASE !</code> These examples are all entered from base set to 10 decimal. To change base you must represent the base desired from the current number base. If in binary and you want to switch back to decimal then <code>1010 BASE !</code> will work. Most Forth implementations have 'words' to shift to common bases, e.g. <code>DECIMAL</code>, <code>HEX</code>, <code>OCTAL</code>, and <code>BINARY</code>.

Why do most computer programming languages not allow binary numbers to be used like decimal or hexadecimal?

<ul>
<li>In VB.NET you could write a hexadecimal number like &amp;H4</li>
<li>In C you could write a hexadecimal number like 0x04</li>
</ul>

Why not allow binary numbers?

<ul>
<li>&amp;B010101</li>
<li>0y1010</li>
</ul>

Bonus Points!... What languages do allow binary numbers?

<hr>

Edit

Wow! - So the majority think it's because of brevity and poor old "waves" thinks it's due to the technical aspects of the binary representation.

Why do most languages not allow binary numbers?

编译器

Java

Perl

为什么大多数计算机编程语言不允许像十进制或十六进制那样使用二进制数？在VB.NET中你可以写一个像&H4这样的十六进制数在C中你可以写一个像0x04这样的十六进制数为什么不允许二进制数？&B0101010y1010加分！...哪些语言允许二进制数？编辑哇！-所以大多数人认为这是因为简洁和糟糕的旧"waves“认为这是由于二进制表示的技术方面。

问为什么大多数语言不允许使用二进制数？
EN

回答 20

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么大多数语言不允许使用二进制数？EN

回答 20

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么大多数语言不允许使用二进制数？
EN