许多“诡异”的计算结果，并不是编译器坑你，而是你不熟“一般算术转换（usual arithmetic conversions）”。本文把规则拆成一条“优先级序列 + 决策树”，再用一组贴身示例验证，读完能在脑子里形成一个稳定的判断框架。

一、为什么你需要这份“优先级序列”

• 结果值可能完全跑偏：unsigned + int，负数会被无符号扩大到巨大的正数。
• 精度悄悄流失：float + 1.0 实际在 double 做，再赋回 float 被二次舍入。
• 可移植性踩雷：long 在不同平台位宽不同；char 的有无符号是实现定义。

如果不知道底层规则，调试像摸黑。掌握它，你能在“看代码”的瞬间预判表达式的共同类型与结果范围。

二、算术转换的两阶段

阶段 A：整型提升（integer promotions）

对所有“比 int 短”的整型（_Bool/char/signed char/unsigned char/short/unsigned short 以及小位宽位段）：

• 若 int 能表明其所有值 → 提升为 int
• 否则 → 提升为 unsigned int

结论：参与大多数运算时，char/short 基本都先变成 int；是否变成 unsigned int 只在极少数“超大无符号短整型 + 极小 int”平台上才会发生。

阶段 B：一般算术转换（匹配共同类型）

在二元算术/位运算（+ – * / % & | ^ 等）和比较中，先做上面的提升，然后按优先级序列找共同类型。

三、类型匹配的“优先级序列”（记这个就够了）

1. 若任一操作数是 long double → 共同类型为 long double
2. 否则若任一是 double → 共同类型为 double
3. 否则若任一是 float → 共同类型为 float
4. 否则（二者都是整型）：
5. 先完成整型提升
6. 若两者同符号（都有符号或都无符号）→ 选择秩（rank）更高者 秩从高到低大致为：long long > long > int（已含提升后的）
7. 若两者一正一无符号 → 按三步规则：
8. 若无符号类型的秩更高 → 共同类型 = 该无符号类型
9. 否则若有符号类型能表明无符号类型的全部值 → 共同类型 = 该有符号类型
10. 否则 → 共同类型 = 该有符号类型的无符号对应型（例如 long ↦ unsigned long）

这三步，解决了“unsigned 有没有把 signed 拉到无符号”的所有疑问。

四、别被这三个细节绕晕

1. float 到底会不会自动变 double？
2. 在本规则里：只要表达式里出现 double，共同类型就会走到 double。
3. 但如果两边都是 float，共同类型就是 float（注意常量 1.0 的类型是 double，1.0f 才是 float）。
4. 移位运算 << >> 是特例
5. 只做整型提升；不做“一般算术转换”。
6. 结果类型是左操作数的类型（提升后）。
7. 右移负数是否算术右移（保符号位）是实现定义；移位计数越界是未定义行为。
8. 取模 % 只接受整型
9. 浮点数参与 % 会直接编译报错。
10. 但它仍会在整型世界里先做提升与共同类型匹配。

五、把规则“落到地上”：可预判的结果类型速查（以主流 LP64* 为例）

*LP64：Linux/Unix 常见 ABI，int 32 位，long 和指针 64 位。Windows（LLP64）略有不同，long 32 位、long long 64 位。请结合你目标平台验证。

• int + unsigned int → unsigned int
• long + unsigned int → long（因 64 位 long 能覆盖 32 位 unsigned int 全部值）
• long + unsigned long → unsigned long（同秩异号，无符号胜）
• long long + unsigned long → unsigned long long（有符号无法覆盖 64 位无符号的全集）
• float + float → float
• float + double / float + 1.0 → double
• double + long double → long double

六、最容易掉坑的 8 个例子

1) 无符号“吞噬”负数

unsigned int u = 1;
int i = -2;
unsigned int r = u + i;   // 共同类型：unsigned int
printf("%u
", r);        // 4294967295（在 32 位无符号上）

i 被转换为无符号，-2 解释为超大正数，结果“绕回去”。

2) 别被 %d / %u 绊倒

unsigned int x = 4000000000u;
printf("%u
", x); // ✅
printf("%d
", x); // ❌ 未定义行为（格式与类型不匹配）

输出格式也要与结果类型匹配；错误的 printf 不是“错几个字节”，而是未定义行为。

3) char/short 参与运算先变 int

unsigned char c = 200; // 提升为 int（因 int 能表明 0..255）
int r = c + 100;       // 共同类型：int，结果 300

多数平台不会变成 unsigned int。

4) float 和 “看似浮点”的常量

float  f = 1.5f;
double d = f + 1.0;  // 1.0 是 double，结果 double
float  g = f + 1.0f; // 共同类型 float，再赋回 float，无额外精度损失

5) long 与 unsigned long long

unsigned long long a = 1ULL;
long b = -1L;                     // LP64：long 64 位
unsigned long long r = a + b;     // 共同类型：unsigned long long

由于“异号不同秩”落入规则第 3 步，结果上升为无符号 64 位。

6) 比较同样遵循共同类型

unsigned int u = 0;
int n = -1;
printf("%d
", n < u); // 共同类型：unsigned int；n 变成超大正数 → 0（false）

7) 移位的“只做提升”规则

int a = -1;          // 假设 32 位
unsigned int k = 1;
int r = a >> k;      // 只做整型提升，不做一般算术转换；结果类型是 int

右移负数的具体位级行为由实现决定（算术/逻辑右移）。

8) % 只在整型里玩

printf("%d
", 7 % 3);    // 1
// printf("%f
", 7.0 % 3.0); // ❌ 编译失败：% 只接受整数

七、一眼判断的“口袋口诀”

• 先晋升，后匹配：小整型先变 int（或极少数平台上的 unsigned int）。
• 浮点三兄弟，谁大听谁的：long double > double > float。
• 整型同号看秩，异号看三步：
• 无符号秩更高 → 选它；
• 有符号能装下无符号全集 → 选它；
• 否则 → 选有符号的无符号对应型。
• 移位是特例：只做提升，结果看左值类型。
• 常量有默认类型：1.0 是 double，1.0f 才是 float；整数字面量带后缀（U/L/LL）明确意图。
• 格式化要对齐：printf 的格式说明符与表达式的共同类型一致。

八、工程实战中的三个“避雷器”

1. 显式后缀与强制类型
2. 用 1u/1ul/1ull/1.0f 表达意图，少让编译器猜。
3. 混合运算前显式强转到你期望的共同类型（但别滥用，保持可读性）。
4. 无符号边界的断言与封装
5. 提供“永不为负”的语义就用无符号，但参与表达式前统一提升到更宽的有符号/无符号类型，封装在内联函数里，避免到处写强转。
6. 跨平台用 sizeof 断言 + 静态分析
7. 通过 static_assert(sizeof(long)==8, “…”) 等在关键模块锁定位宽假设。
8. 开启更高别的告警（如 -Wall -Wextra -Wconversion），早发现隐式转换。

九、一个小练习（自己在脑中跑一遍）

在 LP64 上，下面每行的共同类型分别是什么？

/* A */ unsigned int + long
/* B */ long + unsigned long
/* C */ long long + unsigned long
/* D */ float + 1.0
/* E */ short + char
/* F */ (x << y)   // x,y 为任意整型

参考答案： A=long，B=unsigned long，C=unsigned long long，D=double，E=int，F=仅做整型提升，结果类型为左操作数提升后的类型。

收束 不要死背条文，记住这条“优先级序列 + 三步异号规则 + 移位特例”，再辅以合适的字面量后缀与少量强转，C 语言里的“类型暗涌”基本就稳住了。