跳到主要内容

运算符与表达式

C 的运算符看起来简单,但它们的 优先级、结合性、副作用、求值顺序 是最容易被忽视也最容易出 bug 的地方。这一章把它们讲透。

一、运算符全景​

C 提供约 45 个运算符,可以分成 9 大类:

类别运算符
算术+ - * / % ++ --
关系== != < > <= >=
逻辑&& || !
位运算& | ^ ~ << >>
赋值= += -= *= /= %= &= |= ^= <<= >>=
条件? :
成员. -> [] () (fn call)
指针& * (type)
其他sizeof , _Alignof _Generic (C11)

二、优先级与结合性​

权威表(15 个优先级层,从高到低):

优先级运算符结合性说明
1() [] -> . ++后 --后左→右后缀
2++前 --前 +一元 -一元 ! ~ (type) *一元 &一元 sizeof _Alignof右→左一元/前缀
3* / %左→右乘除
4+ -左→右加减
5<< >>左→右移位
6< <= > >=左→右关系
7== !=左→右相等
8&左→右位与
9^左→右位异或
10|左→右位或
11&&左→右逻辑与
12||左→右逻辑或
13? :右→左三元
14= += -= …右→左赋值
15,左→右逗号

记忆技巧:

  1. 一元 > 二元 > 三元 > 赋值 > 逗号。
  2. 算术 > 移位 > 关系 > 位运算 > 逻辑。
  3. 同类中,乘除 > 加减;位与 > 位异或 > 位或。

三、高频优先级陷阱​

陷阱 1:位运算与关系​

if (x & 0x1 == 0)   // ✗ 实际是 x & (0x1 == 0) = x & 0
if ((x & 0x1) == 0) // ✓ 期望的

== 优先级高于 &!位运算与比较混用时永远加括号。

陷阱 2:移位与加法​

int x = 1 << 3 + 1;   // 实际是 1 << 4 = 16,不是 8 + 1 = 9

+ 优先级高于 <<。

陷阱 3:解引用与后缀 ++​

*p++       // 等价 *(p++):先取 *p,再 p++。**p 移动了**
(*p)++ // 解引用后再 ++:*p 加 1,指针不动
*++p // ++p 后再解引用

陷阱 4:-> 与 ++​

p->x++       // 等价 (p->x)++,成员 x 自增
p++->x // 先 p++,返回原 p,再对原 p 取 ->x
++p->x // 对成员 x 前置自增,等价 ++(p->x)

陷阱 5:条件表达式​

x = a > b ? 1 : 2 + 3;   // 是 a > b ? 1 : (2+3),不是 (a>b?1:2)+3

?: 优先级低于 +。

陷阱 6:赋值作为表达式​

if (a = b)     // 赋值再判断,几乎肯定是笔误(意图 ==)
if ((a = b)) // 显式加括号告诉编译器"我是故意的"

惯用法:字面量放左边——if (42 == x)——写错成 = 会立即编译报错。

四、副作用与序列点​

副作用(side effect)​

副作用是指改变了程序执行环境的运算:

  • 修改变量值(=、+=、++、--)
  • 访问 volatile 对象
  • 调用 I/O 函数

序列点(sequence point)​

序列点是一系列时刻,标准规定:在此之前的所有副作用都已完成,之后的副作用都还没开始。

C99 里明确的序列点:

  1. 完整表达式(; 结束)之后
  2. 函数调用的 参数求值完毕、函数体开始执行之前
  3. &&、||、?:、, 的左操作数求值之后
  4. for、if、while 条件求值之后

C11 起改用「sequenced before」关系描述,本质等价但更严谨。

未定义行为:一个对象的多次修改​

在同一表达式中,若同一对象被 多次修改,或既被修改又被以「与新值无关」的方式读取,结果未定义。

int i = 0;
i = i++; // ✗ UB
i = ++i + i++; // ✗ UB
a[i] = i++; // ✗ UB
printf("%d %d", i++, i++); // ✗ UB(不同编译器结果不同)

正确写法:拆成多个语句。

int t = i;
i++;
i = t;

五、短路求值​

&& 和 || 是 短路运算符:

  • a && b:a 假则不算 b。
  • a || b:a 真则不算 b。

应用:安全解引用与访问:

if (p != NULL && p->x > 0) { ... }   // p==NULL 时不会解引用
if (i < n && arr[i] == target) ... // i>=n 时不越界访问

注意:位运算 &、| 不短路!它们是普通二元运算,两边都必然求值。

六、类型转换规则​

6.1 整型提升(integer promotion)​

在算术运算前,char、short、bool、位域会 先提升为 int(若能容纳所有值),否则 unsigned int。

char a = 100, b = 100;
char c = a + b; // 200 溢出 → -56,但 (a+b) 内部是 int,为 200

6.2 常用算术转换(usual arithmetic conversions)​

二元运算,操作数向 更宽/更浮点 靠拢:

  1. 一方是 long double → 都转 long double
  2. 一方是 double → 都转 double
  3. 一方是 float → 都转 float
  4. 否则做整型提升
  5. 类型不同时按「秩」提升

符号性陷阱:混合有符号 / 无符号时,通常向 无符号 靠拢,见 [[02-数据类型与变量]] 中的例子。

6.3 显式转换​

double d = 3.7;
int i = (int)d; // 截断为 3(向零截断,不四舍五入)
int j = (int)(-3.7); // -3(向零截断)

七、位运算详解​

基本操作​

a & b       // 位与:常用于取位、清零、掩码
a | b // 位或:设置位
a ^ b // 位异或:翻转位、交换、加密
~a // 按位取反
a << n // 左移 n 位(低位补 0)
a >> n // 右移 n 位(无符号补 0;有符号 UB / 实现定义,通常算术右移)

常用惯用法​

// 检查第 n 位是否为 1
if (x & (1U << n))

// 置位
x |= (1U << n);

// 清位
x &= ~(1U << n);

// 翻转
x ^= (1U << n);

// 保留低 n 位
x & ((1U << n) - 1)

// 判断是否是 2 的幂
x && !(x & (x - 1))

// 消去最低位的 1
x & (x - 1)

// 取出最低位的 1
x & -x // 有符号补码技巧

详见 [[12-位操作]]。

八、条件表达式​

expr1 ? expr2 : expr3
  • 求值 expr1,非零则求 expr2 并返回,否则求 expr3 并返回。
  • 结合性右→左:a ? b : c ? d : e 是 a ? b : (c ? d : e)。
  • 类型转换:expr2 与 expr3 会经历常用算术转换,取共同类型作为整体的结果类型。
int max = a > b ? a : b;
int abs = x < 0 ? -x : x;

陷阱:三元表达式不能作为左值:

(x ? a : b) = 42;   // ✗ C 中错误(C++ 中若两侧都是左值则可以)

九、逗号运算符​

int x = (a = 1, b = 2, a + b);   // a=1, b=2, x=3
for (i = 0, j = 10; i < j; i++, j--) ...
  • 从左到右依次求值,返回最右操作数的值。
  • 优先级 最低,比赋值还低。
  • 每个逗号都是一个 序列点(左边求值完毕后才求右边)。

注意区分:函数调用参数列表里的逗号 不是 逗号运算符,而是分隔符。

f(a, b);      // 分隔符,a、b 求值顺序未定义
f((a, b)); // 逗号运算符,一个参数 b(副作用 a)

十、sizeof​

sizeof expr        // 表达式的类型大小(不求值 expr!)
sizeof (type) // 类型的大小

不求值特性:

int i = 5;
size_t s = sizeof(i++); // i 不变,s = sizeof(int)

例外:VLA 的 sizeof 是运行时求值的:

void f(int n) {
int arr[n];
size_t s = sizeof(arr); // = n * sizeof(int),运行时算
}

十一、_Generic(C11)​

类型分派选择表达式:

#define ABS(x) _Generic((x), \
int: abs, \
long: labs, \
double: fabs, \
float: fabsf \
)(x)

double y = ABS(-1.5); // 调用 fabs
int z = ABS(-3); // 调用 abs

编译期根据表达式类型选择匹配分支。是 C 语言中最接近「函数重载」的机制。详见 [[16-高级技巧与惯用法]]。

十二、表达式求值顺序​

核心规则:C 标准 不指定 大多数二元/多元运算符的操作数求值顺序!

int f(void), g(void);
int x = f() + g(); // f() 和 g() 谁先算?未定义!

指定顺序的地方:

  • &&、||、?:、, 的操作数(短路 / 序列点)
  • 函数调用:参数全部求完后才进入函数体(但参数之间顺序未定)

实际影响:涉及副作用时要格外小心:

i = 0;
printf("%d %d\n", i++, i++); // UB

十三、赋值 vs 相等:五花八门的写法​

a = b       // 赋值
a == b // 相等比较
a = b == c // (a) = (b == c),赋值一个 bool 到 a
a == b = c // ✗ 错误:`==` 结果不是左值

十四、复合赋值 vs 手写等价​

a += b;    // 等价于 a = a + b,但 a 只求值一次
arr[i++] += 1; // ✓ i 只自增一次
arr[i++] = arr[i++] + 1; // ✗ UB

复合赋值的这个特性对于带副作用的左值尤其重要。

十五、常见运算符误用速查​

写法意图实际备注
if (x = 5)判断相等赋值 5 再判断真用 ==
x & 1 == 0判断偶数x & (1==0) = x&0 = 0加括号
1 << 3 + 18 + 11 << 4 = 16加括号
*p++(*p)++*(p++)加括号
a > b > c三数比较(a>b) > c,先算 a>b 得 0/1拆开写
1/2 * 420(整数除法)顺序改成 1*4/2 或用浮点
-1U >> 3-1 的右移UINT_MAX >> 3-1U 先转无符号

十六、优先级速记口诀​

按从高到低分组记忆:

1. 括号成员最高               ()  []  .  ->
2. 一元次之(右→左) ++ -- + - ! ~ * & sizeof (type)
3. 算术乘除加减移位 * / % → + - → << >>
4. 关系相等 < <= > >= → == !=
5. 位运算与、异或、或 & → ^ → |
6. 逻辑短路 与、或 && → ||
7. 三元条件(右→左) ? :
8. 赋值(右→左) = += -= ...
9. 逗号最低 ,

实用建议:不要死背优先级表。只记住少数关键顺序,其余全部加括号。可读性远比"炫技少写括号"重要。