二进制、原码反码补码与位运算：从加减法到溢出和移位

很多人在学到二进制和原码、反码、补码的时候，都会卡在一个很尴尬的位置：教材上的定义背得下来，什么“正数的补码等于本身，负数的补码是反码加一”顺口溜也念得很溜，但一遇到实际题目，比如-3 + 5用二进制怎么算、为什么~5等于-6、为什么溢出之后结果是个负数，就彻底懵了。

这篇文章就是想把这些东西彻底讲清楚。我会从最原始的二进制加法开始，一路讲到计算机为什么要用补码、源码反码补码之间怎么快速互转、位运算的直观理解，再配合几个我平时排查时经常用到的实操案例。文章不挑读者，只要你会十进制加减法，能看懂0和1，就能跟着思路走完。看完之后你再回去看课本定义，会发现那些规则不再是死记硬背，而是顺理成章的结果。

1. 从二进制加法开始：进位到底是怎么发生的

1.1 用十进制的老经验理解二进制的“逢二进一”

我们从小到大习惯的十进制，核心规则是“逢十进一”：每一位满10之后，就往高位进1，自己这一位归零。比如19 + 1，个位的9加上1等于10，超过9，所以个位写0，十位进1，结果是20。

二进制完全同理，只不过它是“逢二进一”：每一位最大的数字只有1，当这一位加出来等于2的时候，就要向高位进1，本位写0。也就是说，二进制的每一位只有0和1两种状态，加法表极其简单:

0 + 0 = 0 0 + 1 = 1 1 + 0 = 1 1 + 1 = 0，进位1

最后一行就是关键。1 + 1在十进制里等于2，但在二进制里没有数字2，所以写成10，也就是“本位0，向高位进1”。这个“进位”和十进制里9 + 1进位的逻辑一模一样，只是触发条件从“满10”变成了“满2”。

举个例子，计算二进制1011 + 0110。从最低位开始：

• 最低位：1 + 0 = 1，无进位
• 第二位：1 + 1 = 0，进位1
• 第三位：0 + 1 + 进位1 = 0，进位1
• 第四位：1 + 0 + 进位1 = 0，进位1
• 最后多出一个进位1，写到最高位前面

所以结果是10001。十进制验证一下，1011是11，0110是6，11加6等于17，而10001正好是17。

1.2 多位数加法里“进位链”是重点

如果你手动列竖式算过二进制加法，一定会发现一个现象：进位可能一路传递下去，比如1111 + 0001，最低位1+1进位，第二位又碰到1+1再进位，第三位也是，第四位也是，最后结果变成10000。这个过程在数字电路里叫“进位链”，越长的进位链，加法计算耗时越长。

了解这个对理解CPU底层有帮助，但更重要的是，它能帮你建立一个直觉：二进制加法的运算法则和十进制没有任何本质区别，你完全可以像做十进制竖式一样去算二进制。很多人害怕二进制，其实是害怕那一长串0101的视觉压力，而不是运算本身。

1.3 为什么非要用二进制

这个问题看似基础，但我在实际给别人讲解时发现，问出来的人特别多。本质原因只有两个字：可靠。电子元器件最容易实现的物理状态是“有信号”和“没信号”，也就是高电平和低电平。用二进制，每一位只有两种状态，抗干扰能力强，哪怕电压有一点波动，也不容易把0判成1。

如果非要用十进制，硬件上就得设计出十种可区分的电平状态，这对电路工艺、噪声容限、功耗都是灾难。所以不是二进制多高深，而是物理世界选择了最皮实的方式，然后软件世界在这上面积累起整个数字大厦。

2. 计算机为什么偏要用补码：从正负号到减法变加法

2.1 最自然的想法：用最高位当符号位（原码）

如果让你来设计一个有正有负的二进制表示法，你最可能想到的方案是：拿出一位专门表示正负，0代表正，1代表负，剩下的位表示绝对值。这个方案确实存在，它就叫原码（也叫符号绝对值表示法）。

比如用4位二进制：

• 0001表示 +1
• 1001表示 -1
• 0101表示 +5
• 1101表示 -5

看起来简单直白。但它在运算上有一个致命伤：如果直接用原码做加法，1 + (-1)会得到什么？0001 + 1001 = 1010，也就是-2。正确答案明明是0，这显然不能接受。

要让原码能算，必须额外设计一套“符号位处理规则”，比如先比较两数的符号和绝对值大小，再决定是做加法还是减法，还要处理谁减谁。这样做，逻辑电路会变得非常复杂，运算速度也慢。计算机底层最怕的就是“复杂分支判断”，它喜欢的是“无脑统一处理”。

2.2 反码的过渡：让负数有个合理的“相反数”

为了解决原码无法做减法的问题，有人提出了反码。正数的反码就是自身，负数的反码是“符号位不变，其余位按位取反”。

以4位为例：

• +3 = 0011，反码也是0011
• -3的原码是1011，反码是1100
• +5 = 0101，反码是0101
• -5的原码是1101，反码是1010

反码的好处是，一个数加上它的反码会得到全1。比如3 + (-3)，用反码计算：

0011 + 1100 = 1111

1111在反码体系里代表-0。虽然出现了“负0”这个奇怪的东西，但至少运算结果是自洽的。问题在于反码计算加法时，如果发生了向最高位的进位，这个进位不能直接扔掉，而是要循环加回最低位，这叫“循环进位”，很麻烦。比如3 + (-1)：

3 的反码：0011 -1的反码：1110 相加： 10001，最高位进位1，循环加回最低位：0001 + 0001 = 0010

结果0010是+2，正确。但你看这个过程，多了一步“循环进位”。硬件最怕这种额外步骤，因为和原码一样，需要设计分支判断。

2.3 补码登场：让减法彻底消失

补码的定义更巧妙。正数的补码是自身，负数的补码是“反码加一”，也就是在反码的基础上，最低位再加1。

以4位为例：

• +3 = 0011，补码0011
• -3：原码1011，反码1100，补码1101
• +5 = 0101，补码0101
• -5：原码1101，反码1010，补码1011

补码最漂亮的地方在于，减法可以完全转化为加法。算3 - 1，只需要算3 + (-1)：

3的补码：0011 -1的补码：1111 相加： 10010

这里一共只有4位，最高位的进位1被丢掉（后面会详细解释为什么可以丢），低4位结果是0010，代表+2。正确。

再算-3 + 5：

-3的补码：1101 5的补码： 0101 相加： 10010，丢弃进位，结果是0010 = +2

正确答案确实是2。

更关键的是，计算机里做A - B，根本不需要“减法器”，只需要把B取反加一得到补码，再和A相加。整个CPU里可以只保留加法器，逻辑单元统一、电路简单、速度也快。这是补码最终胜出的决定性理由。

2.4 补码的另一种理解：模运算和时钟模型

如果你对“反码加一”这个规则感觉抽象，我用一个钟表模型帮你建立直觉。

钟面上只有12个数字，12点过后是1点，我们把12当成0。在这个模型里，9 + 4会得到1点，因为9+4=13，13对12取余等于1。这其实是一种“模12”的运算。

再想想，如果你想知道“9点往回拨4小时是几点”，可以往回拨，等价于往前拨8小时，因为9 - 4 = 5，而9 + 8 = 17，17对12取余也是5。在模12的世界里，-4和+8是同一个东西。

二进制定长运算也一样。假设我们只用4位，那么能表示的范围是0到15，实际上所有运算都是在“模16”的世界里进行。在这个世界里，-1的补码1111，等于十进制15，而15确实就是16 - 1。-3的补码1101，等于十进制13，也就是16 - 3。所以一个负数的补码，就是在模16意义下“等价的正数”。

这个视角能解释很多诡异现象：为什么-1的补码全是1？因为16减1等于15，15的二进制正好是1111。为什么补码能统一加法和减法？因为减一个数，就等于加上它的“模补数”，这对硬件来说没有任何区别。

3. 三码对照与转换手算：不背公式也能写对

3.1 原码、反码、补码到底怎么互转

很多人死记硬背“负数的补码等于反码加一”，但换个角度问：给一个补码，怎么求原码？就懵了。

其实记住一句话就够了：所有转换的核心都是“按位取反再处理符号”，而且规则是对称的。负数的反码加一得到补码，补码减一得到反码，反码符号位不变、其余位取反得到原码。这个链条反过来也一样：原码取反得反码，反码加一得补码。

我们用一个表把这三种表示法放在一起看，以5位二进制为例，数轴非常直观：

十进制	原码	反码	补码
+0	00000	00000	00000
+1	00001	00001	00001
+5	00101	00101	00101
-0	10000	11111	不存在
-1	10001	11110	11111
-5	10101	11010	11011

注意表格里有个非常经典的坑：原码和反码都存在“+0”和“-0”两种零，而补码的0只有一个，就是00000。因为-0的原码10000，反码是11111，加一变成100000，5位放不下，丢掉最高位1，又变回00000。补码用一个不存在的“-0”换来了一个额外负数的表示名额，所以补码能表示的范围总比原码、反码多一个负数。

3.2 4位补码范围为什么是 -8 到 7

这个问题几乎每届学生都会问。我们用上面那张表推一次。

4位二进制能表示16种状态。补码把所有状态分为两半：最高位是0的，表示0和正数，从0000到0111，分别对应0到7；最高位是1的，表示负数，从1000到1111。那1000对应多少？按负数的规律，1111是-1，1110是-2，往前推，1000就是-8。所以总共是-8到7，一共16个数，没有多余。

很多教材直接告诉你结果，但很少有人解释“为什么1000是-8”。用模运算理解最简单：4位运算的模是16，1000是十进制8，它作为“某种数”的补码，对应的负数就是8 - 16 = -8。同理，1111是十进制15，15 - 16 = -1。负数补码和十进制的换算，其实只是“把无符号值减去模”而已。

我给你一个很实用的心算技巧：看到负数的补码，先看它是多少（无符号），再用这个数减去2^n，就得到真实值。n是位数。比如8位补码11111100，无符号是252，真实值是252 - 256 = -4。这个技巧比“取反加一”快得多，练熟之后读内存数据会非常舒服。

3.3 手算练习：从补码求原码和十进制值

找几个典型例子，你跟着推一遍，胜过背十遍规则。

例1：8位补码11110110，求它的原码和十进制。

• 判断符号：最高位是1，负数。
• 求补码的真值：无符号值反推，11110110是246，246 - 256 = -10。
• 如果用教科书方法：补码减1得反码11110101，符号位不变、其余取反得原码10001010，也就是-10。两种方法结果一致。

例2：8位补码01101101，求原码和十进制。

• 最高位0，正数，原码、反码、补码三者完全一样，都是01101101。
• 计算十进制：0*128 + 1*64 + 1*32 + 0*16 + 1*8 + 1*4 + 0*2 + 1*1 = 109。

例3：求-25的8位补码。

• 先写25的原码00011001。
• 符号位保持1，符号位不变、其余位取反得反码11100110。
• 加1得补码11100111。
• 验证：11100111无符号是231，231 - 256 = -25，正确。

这种手算熟练之后，你再看调试器里的寄存器值，就能秒读出负数，排查问题效率会明显提升。

4. 位运算实战：按位与、或、异或的直观理解

4.1 位运算是补码的最好应用场景

前面讲的加法、补码，是CPU内部自动完成的。但作为开发者，我们还会直接用到位运算，也就是把两个二进制数按位做逻辑操作。位运算在权限管理、图像处理、状态压缩、底层驱动里都极其常见。

位运算有四种基础运算符，按位与&、按位或|、按位异或^、按位取反~。它们的规则非常直白：

• 与&：两个位都是1，结果才是1。可以理解为“都满足才通过”。
• 或|：两个位有一个是1，结果就是1。可以理解为“有一个满足就通过”。
• 异或^：两个位不相同，结果是1。可以理解为“不一样才通过”。
• 取反~：0变1，1变0。可以理解为“完全反过来”。

几乎所有人第一次看到运算表都能懂，但一写代码就晕。原因在于，位运算是基于整数的“补码表示”进行的，尤其是取反运算，结果经常出乎意料。

4.2 为什么~5等于 -6：负数补码的真面目

我用Python演示一下（C、Java也完全一样）：

a = 5 print(bin(a)) # 输出：0b101 print(~a) # 输出：-6

很多人看到~5等于-6就傻眼：取反之后5应该变成“10”，也就是2，为什么是-6？

关键点在于整数在计算机里的表示不是“只有3位”，而是固定位数（比如8位、32位或64位）。以8位为例，5的二进制是00000101。按位取反后是11111010。这个11111010可不是“无符号的250”，它是一个负数，因为最高位是1。用补码知识还原一下：11111010的无符号值是250，250 - 256 = -6。

所以~5 = -6并不是什么神秘规则，它只是“对5的所有位取反后，解释为有符号数”的必然结果。更深一层：对任意整数n，~n = -n - 1。这也是补码设计带来的数学性质，因为取反相当于“把这个数变成它与模的关系中的相反数”。

我在实际项目里经常用这个性质做快速取负数：-n可以写成(~n + 1)，这在底层代码里很常见，因为有些处理器架构里，取反指令比减法指令更快。

4.3 异或的三大妙用：翻转、判断、交换

异或^是最有意思的位运算，因为它有个特性：a ^ a = 0，a ^ 0 = a。这两个性质组合起来，能做出很多巧妙操作。

第一个用途是翻转指定位。想翻转某个二进制数的第k位，只需要把它异或一个第k位是1、其余位是0的数。比如0b1010 ^ 0b0010 = 0b1000，第1位（从0开始）被从1翻成了0。这个技巧在硬件寄存器操作里非常常用，很多芯片的置位/清位操作就是“读-改-写”加异或。

第二个用途是快速判断两个数是否相等。判断a和b是否相等，可以直接看a ^ b == 0。在有些解释型语言里，这种判断方式可以避免类型转换的一些奇怪副作用。

第三个用途是最经典的交换两个变量，不需要临时变量：

a = 3 b = 7 a = a ^ b b = a ^ b a = a ^ b print(a, b) # 输出：7 3

推一遍：第一次之后a = 3 ^ 7，第二步b = (3 ^ 7) ^ 7 = 3，第三步a = (3 ^ 7) ^ 3 = 7。原理就是异或的对称性。虽然现在编译器优化得很好，临时变量交换也不慢，但在一些资源受限的单片机上，这种写法能省一个寄存器变量，理解它对加深位运算感觉很有帮助。

4.4 位掩码操作：提取、置位、清除

实际开发中更常见的是用位掩码管理多个开关状态，比如一个8位整数存储8个布尔标志位。

• 提取某一位的值：(x >> k) & 1，把第k位移动到最低位，然后与1，就能得到该位的0或1。
• 将某一位设置为1：x | (1 << k)。
• 将某一位清除为0：x & ~(1 << k)，先用1 << k构造一个只有第k位为1的数，取反后，该位是0、其他位是1，与运算就能把目标位清零，其他位保持不变。
• 判断某一位是否为1：if x & (1 << k)。

我举一个真实场景。某设备的状态寄存器只有8位，每位代表一个外设状态。读取到0b01100101后，我想知道第3位（对应ADC模块）是否就绪。做法是：

status = 0b01100101 mask = 1 << 3 # 0b00001000 if status & mask: print("ADC ready") else: print("ADC busy")

这类代码在嵌入式、网络协议解析里随处可见。理解了补码，你就能明白为什么mask取反之后可以用来清位，为什么右移时符号位怎么处理（下面马上讲）。

5. 移位运算与符号扩展：最容易踩坑的地方

5.1 逻辑左移、逻辑右移、算术右移的区别

移位运算也跟补码强相关。左移比较简单，左边位移出去的高位丢弃，右边补0，效果就是乘以2。右移却有两种：

• 逻辑右移：高位补0，适用于无符号数。
• 算术右移：高位补符号位，适用于有符号数。如果原数是正数，高位补0；如果是负数，高位补1，这样能保持负数除以2的语义。

为什么负数右移必须补1？看一个例子。设8位二进制数10001000，它是补码，值是多少？无符号值是136，136 - 256 = -120。如果逻辑右移一位，得到01000100，值是68，和-120除以2差了十万八千里。如果是算术右移，高位补1，得到11000100，无符号值是196，196 - 256 = -60，正好是-120除以2的近似值（实际上是向负无穷取整）。

C/C++里，有符号整数的右移通常是算术右移（取决于实现标准），无符号整数右移是逻辑右移。Python里，>>对有符号数做算术右移，//对负数做向下取整除法，这两个配合起来很有意思。

5.2 符号扩展：从“8位负数”变成“16位负数”

你有没有遇到过这样的场景：从一个字节数组里读出一个有符号的8位值，想把它转成16位或者32位的整数，如果直接赋值，负数可能会变成完全不同的数。

比如8位补码11110110，代表-10。如果把它直接放进16位整数里，高位自动补0，变成0000000011110110，无符号值是246，它代表的是246而不是-10。正确做法是做符号扩展：把原来的最高位（符号位）复制到所有新增的高位。8位的11110110变成16位就是1111111111110110，无符号值是65526，65526 - 65536 = -10，这才对。

在汇编和底层语言里，有专门的指令做符号扩展。高级语言里，很多转换函数也会自动处理，但如果你在解析协议数据时把有符号数当无符号数处理，就会掉进“读出来的负数变成大正数”的坑。我排查过不止一个这类bug，症状都是“采集的温度变成600多度”，原因就是符号位没扩展。

5.3 溢出判断：为什么两个正数相加变负数

补码一个很常见的诡异现象是“溢出”。用4位补码举例，范围是-8到7。计算5 + 4：

0101 + 0100 = 1001

1001是补码，最高位1，代表负数，值是9 - 16 = -7。两个正数相加得到负数，这就是溢出。本质是结果超出了4位补码能表示的正数上限7，跑到负数区域去了。

判断溢出不能只看结果正负，要看两个关键标志：当两个同号数相加，结果符号与加数相反时，说明发生了溢出。因为如果结果在范围内，符号位会保持加数的符号；一旦最高位被进位“污染”，符号位翻转，结果就错了。

我还想强调一个点：溢出和进位是两个概念。进位是最高位产生了一个额外的1，可能会被丢弃；溢出是结果超出有符号数范围。比如4位计算(-1) + (-1)：

1111 + 1111 = 11110，丢弃进位，结果是1110 = -2

虽然有进位，但结果正确，不算溢出。而7 + 1：

0111 + 0001 = 1000，无进位，但结果是-8

没有进位，却实实在在溢出了。做底层调试时，CPU状态寄存器里的进位标志和溢出标志是独立位，就是这个原因。

6. 调试与自查实战：一个8位数值引发的线索

6.1 从实际日志里还原补码过程

有一次我帮某开发者排查协议解析问题，日志里打印出一个无符号字节0xF2，也就是二进制11110010，按无符号是242。而对端文档说这是一个“有符号温度值，单位为0.5摄氏度”。

按补码解析：11110010是负数，无符号值242，242 - 256 = -14，再乘以0.5，得到-7摄氏度。如果没做有符号解析，把242当成真实温度，就会得到121摄氏度，整个上报数据全乱套。

这类问题在物联网设备调试里太常见了。我总结了一个自查顺序：

1. 确认协议里这个字段是有符号还是无符号；
2. 如果有符号，确认是补码表示（绝大多数现代设备都是）；
3. 观察最高位，确定正负；
4. 用“无符号值减去2的位数次方”快速转真实值；
5. 写测试脚本批量验证边界值：0、1、-1、最大值、最小值。

6.2 快速写一个补码换算工具

为了不再手算，我通常在项目里放一个几行的小工具，既能验证思维，也能临时救急。用Python写，最直白：

def to_signed(value, bits): # 将bits位无符号整数转为有符号补码值 sign_bit = 1 << (bits - 1) if value & sign_bit: return value - (1 << bits) return value def from_signed(value, bits): # 将有符号整数转为bits位无符号补码表示 if value < 0: value = value + (1 << bits) return value print(to_signed(0xF2, 8)) # -14 print(from_signed(-7, 8)) # 249

这套代码我几乎逢人推荐。第一个函数的核心就是value - (1 << bits)，也就是前面反复提到的“模数相减”；第二个函数正好反过来，负数加模。理解了原理，这两行代码就会成为你身体的一部分，而不是某个神秘库函数。

6.3 我建议的练习清单：一天时间彻底拿下

如果你想把这块练到肌肉记忆，我给你一份由简到难的自我测试清单，都是我自己带新人时常用的：

1. 写出8位原码、反码、补码各自能表示的范围。
2. 把-128、-1、0、1、127这几个数转成8位补码。
3. 计算35 + (-20)的8位补码加法，验证结果。
4. 验证~35 == -36，并解释原因。
5. 用异或实现两个变量的交换，并写出推导过程。
6. 阅读一个任意字节，判断它代表的有符号数值是多少，要求5秒内给答案。

第6点最关键。一开始不熟练没关系，多算几次以后，你会形成一种条件反射：看到1111xxxx开头的数，脑子里马上跳出一个很负的数。这种直觉，在调试堆栈数据、处理传感器原始值、分析二进制协议时都是无价之宝。

7. 几个我反复讲的知识点误区与边界情况

7.1 “取反加一”到底说的是谁取反

最常见的误区是混淆了“求负数的补码”和“对一个数取反再+1”。实际上，对一个二进制数的所有位取反（含符号位）再加1，得到的是一个数“按位取反并加一”的结果，在补码语义下，它等于原数的相反数。正是因为负数的补码可以通过“原码取反加一”得到，所以很多人把“对一个数全部位取反加一”和“求负数补码”混为一谈。

正确记忆方式：

• 从原码变补码：符号位不变，数值位取反，再加1。
• 对一个已经表示好的补码数值整体取反加一：得到相反数的补码。

两者在最终结果上对负数表现一致，但过程指向的对象不同。我不止一次看到有人对-5的补码11111011再取反加一，得到00000101，以为算错了，其实那恰恰是+5的补码，它验证了“取反加一求相反数”的性质。

7.2 强制类型转换时，正数变负数的那一下

很多高级语言里，把一个大于有符号最大值的数据强制转换成有符号整数，结果会突然变负。比如8位无符号数200，转成有符号8位后是-56。原理很简单：无符号200的二进制是11001000，最高位1，把它解释成补码，就是200 - 256 = -56。

这个现象不是bug，而是“同一串位，换了解释方式”。计算机存储的永远是0和1，无符号和有符号只是解释层的选择。理解了这一点，再看到数据强转后的奇怪结果，就不会慌乱，而是先确认位数、确认符号解释方式。

7.3 为什么原码和反码在现代CPU里“消失”了

严格来说，原码和反码并没有从世界里消失，在浮点数标准、某些特定硬件、协议格式里仍然存在。但在整数算术单元里，它们基本被补码彻底取代了。原因总结下来就三点：

• 补码让加减法共用一套加法器，无需额外减法电路和符号判断逻辑；
• 补码只有一个零，不存在正零负零歧义，比较时会少一堆边界情况；
• 补码能多表示一个最小负数，使数据范围更对称。

这三条对集成电路的成本、功耗、速度都至关重要。所以当你看到教科书花大量篇幅讲原码反码时，不要以为它们只是理论，那其实是理解补码的阶梯：先看两个“有瑕疵”的方案，再体会补码为什么是最优解。

7.4 移位运算配合补码的“整除陷阱”

最后再提醒一个非常隐蔽的坑：用算术右移实现“除以2”时，对负数结果和C语言整数除法并不完全一致。

在C语言里，-7 / 2的结果是-3（向0取整），而-7 >> 1在很多实现里是-4（向负无穷取整）。原因在于，-7的补码是11111001，算术右移一位变成11111100，也就是-4。它不是真正的“除以2”，而是“除以2后向负无穷取整”。当你精心优化代码，用移位替代除法时，必须清楚是否有负数参与运算，否则会引入不易察觉的偏差。

我在嵌入式项目里有一条铁律：只有在明确知道变量非负，或者对负值取整方向不敏感时，才用移位代替除法。否则老老实实写除法，编译器会帮你优化，别自己造轮子。

二进制和补码这块，说难确实不难，说简单也不简单。它真正难的地方在于，人类习惯十进制的“自然语义”，而计算机使用的是二进制的“模运算语义”，两种思维方式需要时间磨合。我的体会是，不要急着背规则，先亲手算几十道题，把符号、进位、溢出这些行为都见一遍，再回头看概念，你会觉得它们都是“显然成立”的事。等你哪天看到0xFF能立刻想到-1，看到0x80能立刻想到最小值，看到0x7F能想到127，这门基本功就算彻底打扎实了。在之后无论是做协议解析、写驱动、搞算法优化还是单纯刷题，你都会感谢当初愿意花时间把这些位级细节抠明白的自己。