blocks|key|829882|text|第一个位只为负数设置(称为符号位)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|829883|详细信息可获得这里|offset|length|829884|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Two%2527s_complement^0|0|7|2|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

The first bit is set only for negative numbers (it's called the sign bit)

Detailed information is available <a href="http://en.wikipedia.org/wiki/Two%27s_complement" rel="nofollow noreferrer">here</a>

blocks|key|591349|text|这正是最重要的位--如果您知道一个数字是有符号的，那么如果MSB=1是编译器(和运行时！)知道把它解释成负面的。这就是为什么类c语言同时有整数(正整数和负数)和无符号整数--在这种情况下，你把它们都解释为正整数。因此，有符号字节从-128到127，而无符号字节从0到255。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|591350|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's exactly that most significant bit -- if you know a number is signed, then if the MSB=1 the compiler (and the runtime!) knows to interpret it as negative. This is why c-like languages have both integers (positive and negative) and unsigned integers -- in that case you interpret them all as positive. Hence a signed byte goes from -128 to 127, but an unsigned byte from 0 to 255.

blocks|key|2121419|text|编译器不知道。如果你把-5投给unsigned+int，你就会得到32763。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|2121420|entityMap^0|0|6|B|2|F|C|X|5|0^^$0|@$1|2|3|4|5|6|7|I|8|@$9|J|A|K|B|C]|$9|L|A|M|B|D]|$9|N|A|O|B|D]|$9|P|A|Q|B|D]]|E|@]|F|$]]|$1|G|3|-4|5|6|7|R|8|@]|E|@]|F|$]]]|H|$]]

The compiler doesn't know. If you cast <code>-5</code> to <code>unsigned int</code> you'll get <code>32763</code>.

blocks|key|829919|text|如果数字被声明为有符号数据类型(而不是类型强制转换为无符号类型)，那么编译器将知道，当符号位为1时，它是一个负数。至于为什么使用2的补语而不是1的补语，你不希望有-0的值，1的补语允许你这么做，所以他们发明了2的补语来解决这个问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|829920|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|$]]

If the number is declared as a signed data type (and not type cast to an unsigned type), then the compiler will know that, when the sign bit is 1, it's a negative number. As for why 2's complement is used instead of 1's complement, you don't want to be able to have a value of -0, which 1's complement would allow you to do, so they invented 2's complement to fix that.

blocks|key|829936|text|编译器知道，因为这是CPU本机使用的约定。您的计算机有一个CPU，它在两个补码表示法中存储负数，所以编译器也会这样做。如果您的CPU支持一个人的补码表示法，编译器将使用它(顺便说一句，IEEE浮点数就是这样)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|829937|维基百科关于这个主题的文章解释了二补表示法的工作原理。|offset|length|829938|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Two%2527s%255Fcomplement^0|0|G|2|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

The compiler knows because this is the convention the CPU uses natively. Your computer has a CPU that stores negative numbers in two's complement notation, so the compiler follows suit. If your CPU supported one's complement notation, the compiler would use that (as is the case with IEEE floats, incidentally).

The Wikipedia article on the topic explains how <a href="http://en.wikipedia.org/wiki/Two%27s%5Fcomplement" rel="nofollow noreferrer">two's complement</a> notation works.

blocks|key|591488|text|处理器实现有符号指令和无符号指令，这将以不同的方式对二进制数字表示进行操作。编译器根据所涉及的操作数的类型知道这些指令中的哪一条(即int和unsigned+int)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|591489|编译器不需要知道数字是否为负数，它只是为所涉及的类型发出正确的机器或中间语言指令。处理器或运行时对这些指令的实现通常也不太关心数字是否为负数，因为两种补码算法的公式对正数或负数都是一样的(事实上，这是两种补码算法的主要优点)。如果一个数字是负数，需要知道的是类似于printf()，正如Andrew指出的，设置的MSBit表示二的补码中有负数。|591490|entityMap^0|1U|3|1Y|C|0|3O|8|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|R|8|@]|D|@]|E|$]]]|I|$]]

The processor implements signed and unsigned instructions, which will operate on the binary number representation differently. The compiler knows which of these instructions to emit based on the type of the operands involved (i.e. <code>int</code> vs. <code>unsigned int</code>).

The compiler doesn't need to know if a number is negative or not, it simply emits the correct machine or intermediate language instructions for the types involved. The processor or runtime's implementation of these instructions usually doesn't much care if the number is negative or not either, as the formulation of two's complement arithmetic is such that it is the same for positive or negative numbers (in fact, this is the chief advantage of two's complement arithmetic). What would need to know if a number is negative would be something like <code>printf()</code>, and as Andrew Jaffe pointed out, the MSBit being set is indicative of a negative number in two's complement.

blocks|key|2121534|text|两种语言的补充部分是机器语言加，减去指令可以忽略所有这些，只需做二进制运算，它就能工作.|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2121535|即-3+%2B4|2121536|在二进制2的补码中，是|2121537|+++1111+1111+1111+1101+++(-3)
%2B++0000+0000+0000+0100+++(+4)
+++-------------------
+++0000+0000+0000+0001+++(+1)|code-block|syntax|javascript|2121538|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|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

The kewl part of two's complement is that the machine language Add, and Subtract instructions can ignore all that, and just do binary arithmetic and it just works... 

i.e., -3 + 4

in Binary 2's complement, is 

<pre><code> 1111 1111 1111 1101 (-3)
+ 0000 0000 0000 0100 ( 4)
 -------------------
 0000 0000 0000 0001 ( 1)
</code></pre>

blocks|key|829957|text|让我们举一个例子:我们有两个字节的二进制数:a=+10010111+B=+00100110+(注意机器不知道这个级别上有符号或无符号的概念)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|829958|现在，当你说“添加”这两个，机器是什么？它只是简单地补充了：|829959|R=+10111101+(进位数:+1)|829960|现在，我们-as编译器-需要解释操作。我们有两种选择:数字可以是签名的，也可以是无符号的。|829961|1-无符号情况:在c中，数字为“无符号字符”，数值为151和38，结果为189。这是微不足道的。|829962|2-签名大小写:我们，编译器，根据他们的msb来解释数字，第一个数字是-105，第二个数字仍然是38。so+-105+%2B+38+=+-67但是-67是10111101。但这是我们已经在结果(R)！结果是相同的，唯一的区别是编译器如何解释它。|829963|结论是，不管我们怎么考虑数字，机器对数字都会做同样的操作。但是编译器会依次解释结果。|829964|请注意，并不是机器知道2的补充的概念。它只是在不关心内容的情况下添加两个数字。然后，编译器查看符号位，决定。|offset|length|style|BOLD|829965|当谈到减法时，这一次，操作是唯一的:取2的第二个数字的补码，并将两者相加。|829966|entityMap^0|0|0|0|0|0|0|0|4|B|16|3|1F|2|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Y|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Z|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|10|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|11|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|12|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|13|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|14|8|@$P|15|Q|16|R|S]|$P|17|Q|18|R|S]|$P|19|Q|1A|R|S]]|9|@]|A|$]]|$1|T|3|U|5|6|7|1B|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|W|$]]

let us give an example:
we have two numbers in two bytes in binary:
A = 10010111
B = 00100110
(note that the machine does not know the concept of signed or unsigned in this level)

now when you say "add" these two, what does the machine? it simply adds:

R = 10111101 (and carry bit : 1)

now, we -as compiler- need to interpret the operation. we have two options: the numbers can be signed or unsigned.

1- unsigned case: in c, the numbers are of type "unsigned char" and the values are 151 and 38 and the result is 189. this is trivial.

2 - signed case: we, the compiler, interpret the numbers according to their msb and the first number is -105 and the second is still 38. so -105 + 38 = -67. But -67 is 10111101. But this is what we already have in the result (R)! The result is same, the only difference is how the compiler interprets it. 

The conclusion is that, no matter how we consider the numbers, the machine does the same operation on the numbers. But the compiler will interpret the results in its turn. 

Note that, it is not the machine who knows the concept of 2's complement. it just adds two numbers without caring the content. The compiler, then, looks at the sign bit and decides.

When it comes to subtraction, this time again, the operation is unique: take 2's complement of the second number and add the two.

In a TC++ compiler, the binary representation of 5 is (00000000000000101).
I know that negative numbers are stored as 2's complement, thus -5 in binary is (111111111111011). The most significant bit (sign bit) is 1 which tells that it is a negative number.

So how does the compiler know that it is -5? If we interpret the binary value given above (111111111111011) as an unsigned number, it will turn out completely different?

Also, why is the 1's compliment of 5 -6 (1111111111111010)?

Two's complement binary form

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

在(00000000000000101).编译器中，5的二进制表示形式为5我知道负数是以2的补码形式存储的，因此二进制的-5是。最重要的位(符号位)是1，这说明它是一个负数。那么编译器如何知道它是-5呢？如果我们将(111111111111011)上面给出的二进制值解释为一个无符号数字，结果会完全不同吗？此外，为什么5...

问二补二进制形式
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问二补二进制形式EN