一个温度采集器通过单字节寄存器上报温度,协议写着“有符号,单位摄氏度”。冬天室外零下,寄存器返回 0xFF。设备面板显示 255 摄氏度,运维以为传感器烧了;换一个程序读,显示 -1 摄氏度,一切正常。同一个字节,两套解析,两个结论。问题不在硬件,而在“这个字节到底是有符号还是无符号”。

这篇从这个小坑出发,把整数在内存里的存法讲清楚。重点不是背“补码等于反码加一”,而是弄明白为什么计算机选了这个方案、-1 为什么全是 1、8 位的范围为什么不对称,以及溢出和符号扩展在真实代码里会以什么形式出现。

现象:同一个 0xFF,两个温度

一个字节有 8 个位,能表示 256 种组合。把它当成无符号整数(unsigned),取值范围是 0 到 255;把它当成有符号整数(signed),取值范围是 -128 到 127。同一个位模式 11111111,无符号解释是 255,有符号解释是 -1。这不是两个存储格式,而是两种解释规则。存储里只有位,符号是人为加上去的约定。

类似的场景到处都是。电量计用无符号字节计数,充满是 255,再充一点就回绕到 0;音频采样用 16 位有符号数,静音是 0,负半周是负数;数据库自增 ID 用无符号大整数,超过上限后回到 0;哈希和校验和用无符号 32 位承载结果,打印成有符号却变成负数。每个现象背后都是同一个问题:这个数的位宽是多少,符号位在哪,谁来负责解释。

更麻烦的是,很多接口不会把符号写清楚。C 的 char 在不同平台默认可能有符号,也可能无符号;协议文档只写“1 字节温度”,不写有无符号;JSON 数字没有位宽概念,解析器却用 64 位浮点或 64 位整数去接。类型边界一模糊,同一个字节就能读出两个世界。

数据库里的整数列同样有这个区分。MySQL 的 TINYINT 有符号范围是 -128 到 127,无符号是 0 到 255;建表时少写一个 UNSIGNED,存进去的 200 就会报越界。迁移数据时,源库是无符号、目标库是有符号,表面上看字段类型一样,实际可用范围差了一倍。排查这类问题时,不要只看列名,要去看完整的类型定义。

音频里的 16 位采样也是同一回事。波形在零点上下摆动,采样值必须能表示负数,所以用有符号 16 位,范围 -32768 到 32767。如果驱动把这段数据当成无符号解析,静音附近的微小负值会变成三万多的大正数,听起来就是刺耳的噪声。数据没坏,解释错了。这类事故在嵌入式设备上并不少见。

场景走查:负数到底怎么存

先看三种曾经被用过的表示法。第一种叫原码(sign-magnitude):最高位当符号位,0 表示正,1 表示负,剩下几位存绝对值。8 位里,+1 是 0000 0001,-1 是 1000 0001。这种表示很直观,但有两个麻烦:0 有两种写法,0000 0000 和 1000 0000 都表示零;做加法时不能直接按位加,得先判断符号,再决定做加法还是减法。

第二种叫反码(ones' complement):正数不变,负数把每一位取反。+1 是 0000 0001,-1 是 1111 1110。它解决了减法的一部分问题,但零还是有两个写法,0000 0000 和 1111 1111。加法运算还要处理“循环进位”,电路不够省。

第三种就是今天普遍使用的补码(two's complement):负数等于对应正数的每一位取反再加一。+1 是 0000 0001,取反得 1111 1110,加一得 1111 1111,所以 -1 在 8 位里就是全 1。补码只有一个零,而且加法可以直接按位进行:1 加 -1 就是 0000 0001 加 1111 1111,进位溢出被丢弃,结果 0000 0000,正好是 0。

可以拿时钟做类比。时钟有 12 个刻度,从 3 点往回拨 5 小时,和往前拨 7 小时,落点一样。模 12 的世界里,减 5 等价于加 7。计算机的 n 位整数就是一个模 2 的 n 次方的计数环,8 位是模 256。减去 1 等价于加上 255,所以 -1 的位模式就是 255 的位模式,也就是全 1。理解了这个“模”的概念,补码就不需要死记,它只是同一个环上的两种走法。

用 5 减 3 验证一下。5 是 0000 0101,3 是 0000 0011。减 3 等于加 -3,-3 的补码是 3 取反 1111 1100 再加一是 1111 1101。两个相加:0000 0101 加 1111 1101 得 1 0000 0010,丢掉最高位的进位,剩下 0000 0010,就是 2。整个过程没有出现减法符号,硬件只做了加法。

原码和反码

直观,容易从人的角度理解符号,但零有重复表示,加减法要额外判断,硬件实现更复杂。

补码

零唯一,加减法共用一套加法器,溢出自然丢弃,硬件最省。代价是范围不对称,负数比正数多一个。

补码的数学解释是把最高位的权重视为负。一个 8 位模式 b7 b6 ... b0,无符号值的算法是各位乘 2 的幂再相加;有符号补码的算法是最高位乘 -128,其余位照常乘正权。以 1111 1111 为例:最高位贡献 -128,其余 7 位贡献 127,加起来是 -1。以 1000 0000 为例:最高位贡献 -128,其余全 0,结果是 -128。所以 8 位有符号的范围是 -128 到 127,负数端比正数端多一个。

这个“多一个”不是设计缺陷,而是补码必然的结果。256 个位模式要分成正、负、零三部分,零占一个,剩下的 255 个是奇数,不可能正负各一半。补码把多出来的那个给了负数,所以 1000 0000 没有对应的正数。这也埋下了一个坑:对 -128 取绝对值,结果还是 -128,因为 +128 在 8 位有符号里根本不存在。

补码的算法:取反加一,还是 2 的 n 次方减 x

求一个负数的补码,有两种等价算法。第一种是“取反加一”:先写出对应正数的二进制,每一位取反,再整体加一。第二种是“模减”:在 n 位里,-x 的位模式等于 2 的 n 次方减去 x。以 8 位为例,-1 等于 256 减 1 等于 255,也就是 1111 1111;-128 等于 256 减 128 等于 128,也就是 1000 0000。两种算法结果一致,模减更容易口算大数。

反过来,从补码还原成数值,也有两种办法。一种是“最高位是负权”,按 -128 加其余位算;另一种是“取反加一再加负号”,先把它当成负数,取反加一得到绝对值。比如 1111 1111,取反是 0000 0000,加一是 1,所以原值是 -1。两种办法都对,选顺手的用。

补码还有一个重要性质:位宽扩展时,正数前面补 0,负数前面补 1。这叫符号扩展(sign extension)。8 位的 -1 是 1111 1111,扩展成 16 位就是 1111 1111 1111 1111,值还是 -1。如果错误地补 0,就变成了 255 或 65535。很多“小类型转大类型后数值突然变大”的 bug,根源就在这里。

减法在补码里就是加上一个负数,所以 CPU 不需要单独的减法电路。这一点在硬件上非常划算:一个加法器,配合取反和进位,就能同时做加法和减法。这也是补码能赢过原码、反码的根本原因,不是因为它“更好懂”,而是因为它“更好造”。

位宽越大,范围越大,但代价是内存和带宽。8 位能表示 256 个值,16 位 65536 个,32 位约 42 亿个,64 位约 1844 京个。选位宽时要先估算业务上限,再留一点余量。一个每天增长 1 万的计数器,用 32 位无符号能撑一百多年,用 16 位不到两年就会回绕。回绕不一定立刻报错,可能只是数据悄悄错了,这比直接崩溃更难查。

另一个容易忽略的细节是,C 里的整数运算会先做整型提升(integer promotion)。两个 uint8_t 相加,会先提升成 int 再算,结果可能超过 255 而不回绕,直到赋回 uint8_t 才截断。所以“两个字节相加会不会溢出”取决于中间类型,不只看操作数。表达式里出现混合类型时,编译器会按一套优先级转换,规则不复杂但容易记错,拿不准就显式写强制转换。

实测:-1、-128 和一次溢出

先看 Python 里按字节观察补码。Python 的整数没有固定位宽,但可以用掩码截到 8 位:

print(-1 & 0xFF)          # 255
print(bin(-1 & 0xFF))     # 0b11111111
print(-128 & 0xFF)        # 128
print(bin(-128 & 0xFF))   # 0b10000000
print(~5)                 # -6
print(~5 & 0xFF)          # 250

本机 Python 3.15 的实际输出是 255、0b11111111、128、0b10000000、-6、250。注意 ~5 单独看是 -6,因为 Python 的按位取反作用在无限位宽的整数上;截到 8 位才是 250。这个差别很容易让人误判:在 Python 里做位运算,通常要配合掩码,不能直接拿负数去和字节比较。

再看 C 里的有符号和无符号解释。下面这段代码把一个字节按两种方式读,并让 8 位有符号数从 127 再加一:

#include <stdio.h>
#include <stdint.h>

int main(void) {
    printf("(int8_t)0xFF = %d\n", (int8_t)0xFF);
    printf("(uint8_t)0xFF = %u\n", (uint8_t)0xFF);

    signed char sc = 127;
    sc = (signed char)(sc + 1);
    printf("127+1 = %d\n", sc);
    return 0;
}

本机 gcc 16.2(MSYS2)编译运行,实际输出:

(int8_t)0xFF = -1
(uint8_t)0xFF = 255
127+1 = -128

第三行的 -128 是补码回绕的结果:127 是 0111 1111,加一变 1000 0000,按有符号解释就是 -128。这里必须说清楚,C 标准对有符号整数溢出并不保证回绕,严格来说这是未定义行为(undefined behavior,简称 UB),编译器有权做任何事。上面能得到 -128,只是当前编译器在当前优化级别下的实际表现,不能当成可移植的规律。生产代码要么用无符号类型做回绕,要么在加法前检查边界。

还有一个常见的实测现象:把 0xFF 赋给有符号 char,再传给 printf 用 %d 打印,结果是 -1 而不是 255。因为 char 在多数 x86 平台上默认有符号,0xFF 被解释成 -1,传给可变参数时又做了符号扩展,所以看到 -1。换成 %u 或先转成 unsigned char,才会得到 255。

Python 的 struct 模块把“位宽加符号”写进了格式字符串,可以拿来验证边界。小写 b 表示有符号字节,大写 B 表示无符号字节:

import struct

print(struct.pack('<b', -1))   # b'\xff'
print(struct.unpack('<b', b'\xff'))  # (-1,)
print(struct.unpack('<B', b'\xff'))  # (255,)
try:
    struct.pack('<b', 128)
except struct.error as e:
    print(e)  # 'b' format requires -128 <= number <= 127

本机 Python 3.15 实际输出:b'\xff'、(-1,)、(255,),最后一行是 'b' format requires -128 <= number <= 127。这个报错说明格式化层是认真的,超出范围直接拒绝,而不是悄悄回绕。相比之下,C 的强制转换不会报错,只会按实现行为截断,所以更危险。

现象对照表

现象真实原因第一步查什么
温度 0xFF 显示成 255 摄氏度按无符号解析,协议实际是有符号看协议字段的符号定义,确认解析函数的类型
电量 255 之后跳到 0无符号 8 位计数器回绕,256 取模看计数器类型和上限判断,必要时提升位宽
小类型转大类型后数值突然变大负数被零扩展而不是符号扩展检查转换路径,确认是否有 unsigned 中转
对 -128 取绝对值仍是负数8 位有符号范围不对称,+128 不存在先提升到更宽的类型,再取绝对值
两个正数相加变成负数有符号溢出,结果不可靠加边界检查,或改用更宽/无符号类型
负数右移后越来越负算术右移补符号位,和逻辑右移不同确认语言和编译器的右移规则,必要时转无符号
哈希值打印成负数无符号结果被有符号类型承载统一用 uint32_t 或无符号格式化输出
解析字符串里的 -1 失败解析函数只接受无符号,或遇到负号就停止看解析函数的签名和错误处理,换有符号解析

边界与代价

补码的代价首先体现在范围不对称。8 位是 -128 到 127,16 位是 -32768 到 32767,32 位是 -2147483648 到 2147483647。负数端总比正数端多一个,所以“正数和负数的绝对值一样多”这个直觉是错的。做区间映射、取绝对值、算距离时,要小心这个边界。比如两个 32 位有符号数相减,结果可能超出 32 位范围,正确做法是先转成 64 位再减。

第二个代价是未定义行为。C 和 C++ 里,有符号溢出是 UB,编译器可以假设它不会发生,从而做各种优化。一个常见的例子是循环条件 for (int i = 0; i <= n; i++),如果 n 是 INT_MAX,i 加到溢出后循环可能永远不结束,也可能被优化成完全不同的行为。Java 明确规定了溢出回绕,Rust 在调试构建下会 panic、发布构建下回绕,Python 直接提升到大整数。每种语言的选择不同,跨语言移植时不能照搬假设。

第三个代价是移位和除法的不一致。负数右移在 C 里是实现定义的行为,常见编译器做算术右移,补符号位,所以 -1 右移一位还是 -1;逻辑右移则补 0,会变成一个大正数。除法向零取整,右移向下取整,两者对负数结果不同:-3 除以 2 得 -1,-3 右移一位得 -2。把除法优化成移位,是编译器在确认非负的前提下才敢做的事,手写代码时别自己乱替。

第四个代价是类型转换的隐式规则。C 里 signed 和 unsigned 混算时,signed 会被转成 unsigned,负数会变成一个很大的正数。比如 if (a < b),a 是 int 的 -1,b 是 unsigned 的 1,比较时 -1 变成 4294967295,条件为假。这类 bug 很隐蔽,编译器警告有时能提示,但不能全指望它。涉及位模式时,明确用无符号类型;涉及数值计算时,明确用有符号类型,别让它们混在一起。

最后是“位模式”和“数值”的心智负担。同一个变量,做算术时是数值,做掩码时是位模式。补码让这两件事共用一套存储,很方便,但也容易让人忘记当前在做哪一种。看到 0xFFFFFFFF,它可以是 -1,也可以是 4294967295,还可以是一组全 1 的标志位。判断依据不是这个字面量,而是它的类型和上下文。

落到工程实践上,有几条能直接减少事故。第一,协议和文件格式里明确写“signed”还是“unsigned”,最好连位宽一起写死,比如“int16 little-endian”。第二,不要用 int 去存哈希、校验和、颜色值这类纯位模式,改用对应宽度的无符号类型。第三,跨语言传递整数时,先确认目标语言有没有 64 位整数,JavaScript 的 Number 只能精确表示到 2 的 53 次方,再大就会丢精度。第四,看到负数参与位运算,先把它截到目标位宽再加掩码,别让符号位无限延伸。

当天能自己验证的练习

  1. 用 C 打印 (int8_t)0xFF 和 (uint8_t)0xFF,再用 %d 和 %u 分别输出,观察同一字节的两种读法。
  2. 用 Python 写一个循环,把 0 到 255 每个字节按有符号解释一遍,打印 0x80 到 0xFF 对应的负数,确认 -128 到 -1 的映射。
  3. 写一个函数,把 8 位有符号数符号扩展到 16 位,输入 0x80 应得到 0xFF80,也就是 -128;再用零扩展对比结果。
  4. 用 uint8_t 写一个从 250 开始加 10 的循环,观察它在 255 之后回到 0;再换成 int 看结果差异。
  5. 找一个编译器支持溢出检查的选项,比如 gcc 的 -fsanitize=undefined,跑一个故意让 int 溢出的程序,看它是否报错。本机只验证了普通编译下的回绕现象, sanitizer 这一条未在本机实测。

小结与下一篇

整数在内存里只有位,符号是解释规则。补码把最高位当成负权,-1 因此全是 1,8 位范围是 -128 到 127,零只有一种写法,加法和减法共用一个加法器。代价是范围不对称、有符号溢出属于未定义行为、负数右移和除法规则不统一,以及有符号与无符号混算时的隐式转换。

看到一个小类型或一个字节,先问三件事:位宽多少、有没有符号、下一步会把它转成什么类型。这三问答清楚,大部分“数值突然变了”的问题都能定位。整数只能表示离散的整数,那 0.1 这种小数在内存里又长什么样?下一篇讲0.1 + 0.2 为什么不等于 0.3:浮点与 IEEE 754,看看小数点的位置是怎么被“浮动”起来的。