C语言运算符优先级：读懂这些陷阱，写代码不再靠猜

很多刚开始学 C 语言的朋友，几乎都会在某一个节点被运算符给卡住。明明 ++、*、&、|| 这些符号单独拿出来都认识，一组合到一起，比如 *p++、a & b == c、ch = getchar() != EOF，结果就完全看不懂了。标题里说得对，C 语言运算符难懂，但搞清优先级就好学。我把这么多年看代码、写代码、帮人改代码的经验整理一下，希望能帮你把这个最大的坎迈过去。

先说点实在的：优先级不是靠死记硬背背下来的，而是要理解 C 语言设计者“怎么想”的，再配合几个高频陷阱案例，基本就通了。我还会把那些笔试面试常考的运算符组合、实际开发中踩过的坑，一并整理出来。你不用一次全记住，把这篇文章收藏起来，遇到问题回来查，比直接翻手册要快得多。

1. 优先级没搞懂，代码就是在“猜谜”

1.1 从“读代码”到“写代码”之间，隔着一层优先级理解

C 语言的运算符数量很多，粗算下来有 40 多个。新手最痛苦的一点是：这些符号在表达式中同时出现时，到底先算谁？比如下面这行：

c复制int result = a++ + b * c - --d;

如果没有优先级规则，这行代码可以有几十种解读方式。但有了完整的优先级体系，它可以被严格翻译成：

c复制int result = ((a++) + (b * c)) - (--d);

优先级决定的是“谁先结合”，不是“谁先执行”。这是个很重要的细节。优先级只定了解析的顺序，真正执行的时候还涉及求值顺序、副作用等更多规则。先把优先级搞明白，就已经解决了 80% 的代码阅读问题。

我当年带新人的时候，发现一个普遍现象：很多人写多条件判断时，会“习惯性”加一堆括号。问他们为什么要加，回答是“怕出错”。这个思路本身没错，但如果你能真正理解优先级，绝大多数括号其实是可以省掉的。省不省括号不是关键，关键是：看到别人的代码时，你得知道他写的那些括号是什么意思，他为什么这么写。

1.2 一张表记住整个优先级体系

C 语言标准把运算符优先级从高到低分成了 15 个级别。我把它们整理成了一张速查表，建议你把它存下来：

这张表有个记忆规律：后缀最高，赋值最低；单目次高，逗号垫底；算数高于移位，移位高于比较，比较高于位运算，位运算高于逻辑运算。

真正需要花时间记的，其实是中间的“关系区”。因为算术、赋值、逗号这些在直觉上比较符合常理，难的是下面这几个层次之间微妙的关系：

1. 移位运算符（<<、>>）优先级比算术运算符低，但比关系运算符高；
2. 关系运算符（<、> 等）比相等运算符（==、!=）高；
3. 相等运算符又比按位与（&）高；
4. 按位运算的优先级整体高于逻辑运算。

这几个“中间地带”就是无数 C 语言笔试题的出题重灾区。后面我会逐个拆开讲。

2. 最容易踩坑的优先级细节

2.1 赋值运算符和比较运算符：= 和 == 的经典陷阱

很多人以为只有新手才会把 == 写成 =。实际上，这两种写法在优先级上的差异会导致完全不同的问题，老手也会在匆忙中犯错。

看这段代码：

c复制int a = 5;
if (a = 3) {
    printf("a is 3\n");
}

这里有一个非常恶劣的行为链：赋值运算符 = 的优先级非常低，所以 a = 3 作为一个整体先被执行，a 被赋值为 3；然后 if 判断这个赋值表达式的值，也就是 3，非零即为真。最终结果是：条件成立，且 a 的值被改成了 3。

本来想判断 a 是否等于 3，结果变成了把 a 改成 3。这个 bug 在编译时往往不会报错，因为它语法合法。唯一的排查途径是开启编译器警告，GCC 加 -Wall 会提示可能少写了 ==。我在实际项目里见过这种 bug 引发的线上事故，排查了两三个小时。

反过来，如果判断的是一个变量是否为 0，有人会写：

c复制if (x = 0)

这行代码直接把 x 赋值为 0，条件永远是假，后面的代码块永远不会执行。这种写法在逻辑上往往会导致非常诡异的现象——代码能编译、能运行，但就是不走那个分支。

经验之谈：如果你要判断一个值是否等于某个常量，可以把常量写在左边，写成 if (3 == a)。这样万一你写成 if (3 = a)，编译器会立刻报错，因为不能给常量赋值。这个习惯能帮你拦下一大批低级错误。

2.2 位运算优先级低于相等运算符：a & b == c 的迷惑行为

位运算符的优先级低于相等运算符，这是个非常反直觉的设计。因为按位与（&）通常在数学感觉上比 ==“更紧密”，但在 C 语言里恰恰相反。

来看最常见的错误：

c复制// 想判断 (a & b) 是否等于 c
if (a & b == c) {
    // ...
}

按照优先级规则，== 的优先级高于 &，所以这行代码实际是：

c复制if (a & (b == c)) {
    // ...
}

b == c 先被比较，得到一个 0 或 1 的结果，然后 a 再与这个结果做按位与。逻辑上跟你想要的完全不同。

这种写法在嵌入式开发的寄存器判断中特别常见。比如你想检查某个状态寄存器的 bit3 是否为 1，通常写成：

c复制if (status & 0x08 == 0x08)

结果这个表达式实际是 status & (0x08 == 0x08)，即 status & 1。只有当 status 的最低位为 1 时条件才为真，而这不是你想要的。正确写法是：

c复制if ((status & 0x08) == 0x08)

这个坑我见过太多人踩了。它的核心问题就是优先级表中“位与低于相等”这一条。类似的组合还有 a | b == c、a ^ b == c，全部都要加括号。

2.3 逻辑与和逻辑或的短路求值

&& 和 || 的优先级在整个表里排得比较靠后，只比三目运算符和赋值运算符高。这意味着它们通常能“罩住”两侧大部分的运算，执行时按照从左到右的顺序求值，一旦结果确定，就不再继续往后算。

短路求值在实战中特别有用，但如果不理解它，代码也容易写得有问题。举个例子：

c复制int arr[10] = {0};
int i = 5;
if (i < 10 && arr[i] > 0) {
    // ...
}

因为 && 左侧 i < 10 为真，才继续判断右侧 arr[i] > 0。这是正常的用法。但如果把左侧换成 arr[i] > 0 && i < 10，当 i 一开始超出数组范围时，arr[i] 访问的就是越界内存，可能在判断 i < 10 之前就出事了。

再看一个常见写法：

c复制if (ptr != NULL && ptr->value == 10) {
    // ...
}

&& 左侧先判断指针是否为空，只有不为空才解引用访问成员。这就是短路求值的价值。如果把顺序反过来，写成了 ptr->value == 10 && ptr != NULL，那在 ptr 为空时程序直接就段错误了。这是面试中非常喜欢问的点，也是实际开发里基础的安全意识。

另外补充一点：|| 的短路规则类似，左侧为真就不再算右侧。这个特性经常被用来写“兜底”逻辑：

c复制value = getValue() || DEFAULT_VALUE;

这里 getValue() 如果返回非零值，value 就得到这个值；如果返回 0，value 就得到 DEFAULT_VALUE。在很多 C 风格代码里会把这种写法当成简化分支的惯用法，但前提是你得清楚短路规则，否则容易误读。

2.4 取余运算 % 的细节：不止是除完取余数

% 这个运算符在优先级表里和 *、/ 同级，都是从左到右结合。它很简单，但有几个细节值得说一说。

第一，它只能用于整数。对浮点数取余会编译报错。如果你想对一个 double 类型取余，C 标准库里提供的是 fmod 函数：

c复制#include <math.h>
double result = fmod(7.5, 2.0);

第二，负数取余的结果符号。C 语言标准规定，取余结果的符号与被除数一致。比如 -7 % 3 的结果是 -1，7 % -3 的结果是 1。这在某些算法中会产生和 Python 不一样的结果，跨语言移植时需要注意。Python 的 -7 % 3 会得到 2，因为 Python 的取模运算是向下取整，而 C 的取余是截断除法。习惯用 Python 写算法的人，转 C 语言后在这个点上容易翻车。

第三，利用取余判断闰年的经典写法。年份能被 4 整除但不能被 100 整除，或者能被 400 整除，就是闰年。写成表达式：

c复制if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)

这里为什么要在 % 的结果后面接 == 0？因为 % 的优先级高于 ==，不需要括号把 year % 4 包起来。这个表达式是安全的，但很多人为了增强可读性，会写成 (year % 4) == 0。两种都对，看你个人的代码风格。

2.5 强制类型转换运算符的优先级陷阱

类型转换也是运算符，它的优先级落在“单目运算符”这一层，仅次于后缀运算符。但这里有一个常见的误用场景。

看这个例子：

c复制double result;
int a = 5, b = 2;
result = (double)(a / b);

你以为先转成 double 再除，结果是 2.5，但实际上 (a / b) 内的除法已经按整数除法执行完毕，结果是 2，然后再转成 double，最终结果是 2.0。正确写法是：

c复制result = (double)a / b;

这里 (double)a 先把 a 转成 double，然后 double / int 发生隐式类型提升，b 自动转成 double，得到 2.5。由于强制类型转换属于单目运算符，它的优先级比除法高，所以 (double)a / b 会被解析为 ((double)a) / b，完全没有问题。

这个细节在涉及时间计算、平均值计算的时候特别容易出问题。比如：

c复制int total = 7;
int count = 2;
double avg = (double)total / count;   // 正确
double avg = total / (double)count;   // 也正确
double avg = (double)(total / count); // 错误，得到 3.0 而不是 3.5

三种写法看似都加了 (double)，但位置不同结果完全不同。这个点笔试常考，因为它的确很隐蔽。

3. 指针、数组和运算符优先级的联合实战

3.1 *p++、(*p)++、*++p：一个字符之差，结果天差地别

C 语言里最让新手头皮发麻的，就是 *、++、-- 这几个运算符的组合。核心规则其实只有一条：后缀 ++ 和 -- 的优先级比 * 解引用高，比前缀 ++ 和 -- 也高。

逐一看几个例子：

c复制int arr[5] = {10, 20, 30, 40, 50};
int *p = arr;

printf("%d\n", *p++);   // 先取出 p 指向的值 10，然后 p 向后移动一位
printf("%d\n", *p);     // 此时 p 指向 arr[1]，输出 20

p = arr;
printf("%d\n", (*p)++); // 取出 *p 的值 10，输出 10，然后 arr[0] 变成 11

p = arr;
printf("%d\n", *++p);   // p 先向后移动一位，再取当前指向的值，输出 20

逐行解释一下：

• *p++ 由于后缀 ++ 优先级高，等价于 *(p++)。整个表达式先把 p 当前指向的值取出来，输出 10，然后 p 自增，指向 arr[1]。这是遍历数组时非常常见的写法。
• (*p)++ 加了括号，让 * 先作用于 p，得到 arr[0] 的值 10，然后对这个值做自增。结果是输出 10，但 arr[0] 变成 11。
• *++p 前缀 ++ 和 * 优先级同级，结合性是从右到左，所以先执行 ++p，再解引用。得到的是 arr[1] 的值 20。

这三个表达式在实际代码里都非常常见。很多人读到 *p++ 时以为是“先让 p 加 1，再取指向的值”，这是完全反的。一定要记住一个口诀：后缀自增自减的含义是“先取后用，事后加”。它虽然表面上和 * 写在一起，但优先级决定了 p++ 作为一个整体动作，先计算出“p 当前的值”，然后再让 p 加一。这是个“推迟”的副作用。

3.2 [] 和 * 的等价关系：a[i] 的本质是 *(a+i)

数组下标运算符 [] 在优先级表中和函数调用一样，属于最高一级。但它本质上可以换算成指针运算，这是理解数组和指针关系的桥梁。

C 语言标准规定：对于数组 a 和整数 i，a[i] 严格等价于 *(a + i)。这个等价关系意味着你可以写 i[a]，虽然没人会这么写，但语法是合法的，因为 *(i + a) 跟 *(a + i) 完全一样。

这个等价关系在遇到指针和数组混合的表达式时很有用。假设：

c复制int arr[3][4] = {0};
int (*p)[4] = arr;

p 是一个指向“含 4 个 int 的一维数组”的指针。要理解 p[1][2]，可以先把它还原成 *(*(p + 1) + 2)。外部 *(p + 1) 获取到第二行的首地址，再往后偏移两个 int，得到 arr[1][2]。这里的优先级关键在于：两次 * 解引用的层级关系，以及 + 在每一步中的位置。如果不理解这种嵌套解引用，二维数组的指针操作基本没法写对。

再比如，想写一个函数，接受二维数组并遍历它：

c复制void printMatrix(int (*matrix)[4], int rows) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < 4; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }
}

现在回头看 matrix[i][j]，其实就是 *(*(matrix + i) + j)，编译器在解析时完全依赖优先级规则，一层一层解引用。

3.3 函数指针声明与优先级：为什么 int *f() 和 int (*f)() 完全不一样

函数指针是 C 语言学习中的另一个重点难点，而它的核心也离不开优先级。

看两个声明：

c复制int *f();
int (*f)();

• int *f()：f 是一个函数，它没有参数，返回值是 int* 类型指针。
• int (*f)()：f 是一个函数指针，它指向一个没有参数、返回 int 的函数。

为什么同样的符号，位置不同含义完全不同？因为 () 是后缀运算符，优先级很高。第一个声明中，f 先和 () 结合，说明 f 是函数，然后返回值类型是 int*。第二个声明中，括号改变了结合顺序，*f 先结合，说明 f 是个指针，它指向的对象的类型是“一个返回 int 的无参函数”。

这个知识点几乎是 C 语言笔试的必考题，也是很多嵌入式 SDK 里函数回调的原型基础。比如：

c复制typedef int (*callback_t)(int, int);
void registerCallback(callback_t cb) {
    // 函数指针用于注册回调函数
}

一旦适应了用“优先级 + 结合性”来拆解声明，这类代码就很容易看懂。

另外，还有一个经典的复杂声明题：

c复制char *(*fp)(int);

拆解方式：先看 fp，它左边有 *，说明 fp 是指针；再看右边有 (int)，说明它指向的是一个接受 int 参数的函数；函数返回类型是 char *。结论：fp 是一个函数指针，指向“接收一个 int 参数、返回 char* 类型”的函数。

3.4 指针数组还是数组指针？

int *p[4] 和 int (*p)[4] 这两个声明的优先级区分，也是被问烂了但每次都能考倒一批人的点。

• int *p[4]：p 先与 [] 结合，所以 p 是一个数组，数组有 4 个元素，每个元素是 int* 类型的指针。这是一个“指针数组”。
• int (*p)[4]：括号让 * 先与 p 结合，所以 p 是一个指针，它指向“含 4 个 int 元素的数组”。这是一个“数组指针”。

它们两者在内存布局和用法上完全不同：

c复制// 指针数组：每个元素指向一个 int
int a = 1, b = 2, c = 3, d = 4;
int *p[4] = {&a, &b, &c, &d};

// 数组指针：指向含 4 个 int 的数组
int arr[4] = {1, 2, 3, 4};
int (*q)[4] = &arr;

很多初学者会混淆这两个概念，进而写出类型不匹配的代码。要彻底搞清楚，需要记住优先级表：[] 的优先级高于 *，所以不加括号就是数组优先；加了括号就强制指针优先。

4. 自增自减、三目运算符与真实场景的混用分析

4.1 后缀 ++ 的本质：一个“先取后用”的延时副作用

C 语言最精妙也最危险的地方，就是自增自减运算符的副作用。很多人知道后缀 ++ 是“先用值，再加一”，但在复杂的表达式中，什么时候“用值”其实也存在未定义行为的边界。

举个例子：

c复制int i = 1;
int arr[5] = {0};
arr[i++] = i;

这行代码在很多编译器中结果可能是 arr[1] = 1 或 arr[1] = 2，因为左边和右边同时使用了 i，而求值顺序不确定，属于未定义行为。这是 C 标准明确禁止的写法：同一个变量在同一个表达式中被多次修改，且修改和读取之间没有序列点，结果就是未定义的。

所以，实战经验里有一条铁律：不要把自增自减嵌入到过于复杂的表达式中。定时器处理代码里常见的写法：

c复制counter = (counter + 1) % 10;

就比 counter = counter++ % 10; 要安全得多。前者不存在任何歧义，后者则会因为自增的副作用和取余的顺序问题，在优化级别不同的编译器上可能产生不同结果。这类坑极其隐蔽，一旦线上出了问题，排查起来会非常痛苦。

4.2 三目运算符 ?:：优先级低到几乎只比赋值高一点点

三目运算符 ?: 的优先级只比赋值运算符高，比逻辑或还低。这意味着你在写 a ? b : c 的时候，大概率不需要为整个表达式加外层括号，但如果三目运算符嵌套出现了问题，混乱程度会指数级上升。

看一个经典混淆：

c复制int a = 1, b = 2, c = 3;
int result = a > b ? a : b > c ? b : c;

这里有两个 ? :，由于 ?: 的右结合性，它等价于：

c复制int result = a > b ? a : (b > c ? b : c);

也就是先判断 a > b，如果为真结果取 a，否则进入第二个三目判断 b > c，取较大的值。整体逻辑是取三个数中的最大值。如果你不熟悉右结合性，可能会误读成 (a > b ? a : b) > c ? b : c，结果就完全错了。

实际开发中，我一般建议三目运算符最多嵌套一层，超过一层的就直接改写为 if-else。这不是因为三目运算符有性能问题，而是因为可读性。如果你返工去维护别人写的三四层嵌套三目表达式，你会非常想跟写这段代码的人“聊聊人生”。有些公司甚至把“禁止嵌套超过两层的三目运算符”写进编码规范，我觉得这是合理的。

4.3 真实场景：冒泡排序中的交换操作为什么这么写

冒泡排序是 C 语言入门的必写算法。它的核心操作就是交换两个元素。常见写法：

c复制int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;

用运算符来体会的话，这个赋值表达式整体是从右到左结合的，arr[j+1] = temp 中的 [] 优先级高于 +，所以 arr[j+1] 被正确解析为下标访问。这里没有 ++ 的干扰，逻辑清晰。

如果你看到有人用“无临时变量交换法”：

c复制arr[j] = arr[j] ^ arr[j+1];
arr[j+1] = arr[j] ^ arr[j+1];
arr[j] = arr[j] ^ arr[j+1];

这种写法利用了异或运算的性质，但 ^ 的优先级低于赋值，所以 arr[j] = arr[j] ^ arr[j+1] 完全等价于 arr[j] = (arr[j] ^ arr[j+1])，没有问题。可它的可读性确实不如临时变量法，而且在某些数值相同的情况下可能引发难以预料的副作用，我一般不建议在实际项目里这么写，知道原理就好。

4.4 字符串逆序与指针自增自减的组合应用

热词里有“字符串逆序 c语言 pta”，这类题目在在线判题平台上非常常见。由于需要移动指针并交换字符，这里优先级理解就显得很关键。

一个典型的解法：

c复制void reverseString(char *str) {
    if (str == NULL) return;
    char *left = str;
    char *right = str;
    while (*right != '\0') {
        right++;
    }
    right--;  // 指向最后一个有效字符

    while (left < right) {
        char temp = *left;
        *left++ = *right;
        *right-- = temp;
    }
}

这里的关键语句是 *left++ = *right--。拆分来看，后缀 ++ 优先级高于 *，表达式等价于 *(left++) = *(right--)。含义是：先把 left 当前指向的字符作为赋值目标，把 right 当前指向的字符赋给它；赋值完成后，left 和 right 分别向后、向前移动一位。

如果你错误地去掉或加错括号，比如写成 (*left)++ = (*right)--，那语义就变成给字符做自增自减再赋值，整个字符串就被改乱了。所以这类题目既能考察算法思维，也在暗中考察运算符优先级的基本功。

4.5 日期计算中的表达式写法：年、月、日换算

热词里还有“输入一个日期的年、月、日，计算并输出这天是该年的第几天”，这也是典型的综合练习题。

常见的实现思路是存一个每月的天数表，然后累加。这里有个细节：判断闰年时需要先处理优先级问题。

c复制int daysInMonth[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int dayOfYear = 0;

if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
    daysInMonth[1] = 29;
}

for (int i = 0; i < month - 1; i++) {
    dayOfYear += daysInMonth[i];
}
dayOfYear += day;

这里的 year % 4 == 0 由于 % 优先级高于 ==，不需要写成 (year % 4) == 0。但 year % 4 == 0 && year % 100 != 0 这个整体逻辑，如果不清楚 && 的优先级比 == 低，也容易误读。其实编译器会把它解释为 ((year % 4) == 0) && ((year % 100) != 0)，正是我们想要的。

这类多条件组合的判断，本身就是优先级知识的综合应用。我看过不少新人在这种题里加了一整套括号，效果是对的，但自己解释不清为什么要加。我的建议是：你可以加括号，但一定要分清楚哪些括号是必需的、哪些只是语义强调。真正理解了优先级，代码写出来才心里有底。

5. 常见问题与排查技巧实录

5.1 这类问题太常见了：加个括号就行，但为什么加、加在哪儿？

优先级相关的 bug，最典型的特征就是“编译不报错，运行结果不对”。你检查逻辑时觉得每个条件都对，但输出就是不符合预期。我分享一个排查思路。

第一步，把所有涉及多个运算符的表达式找出来，逐个用括号重写一遍，确定编译器真实的解析顺序。这个动作不要凭感觉，要对照优先级表。

第二步，重点关注涉及 &、==、!=、 && 混用的表达式。这类表达式是重灾区，因为它们的优先级层级相邻，非常容易记混。

第三步，加上 -Wall -Wextra 重新编译。GCC 和 Clang 对某些常见的优先级问题会给出警告，比如 -Wparentheses 就是专门提示这种问题的。

第四步，也是最笨但最有效的方法：在关键表达式处打印中间值。比如：

c复制printf("a = %d, b = %d, (a & b) == c = %d\n", a, b, (a & b) == c);

这样能立刻看出实际执行顺序和你预期的是否一致。

5.2 一个真实的排查案例：RGB 颜色合成中的位运算优先坑

我早年写一个嵌入式 GUI 程序时，需要把 R、G、B 三个分量合成一个 16 位颜色值。当时简单写成了：

c复制uint16_t color = r << 8 | g << 4 | b;

这个表达式看起来完全没问题，因为 << 的优先级高于 |，编译器会解析为：

c复制uint16_t color = (r << 8) | (g << 4) | b;

这是一个正确的表达式。但如果换成：

c复制uint16_t color = r << 8 && g << 4;

这就完全变味了，&& 左右两侧都会先移位，再逻辑与，得到的结果只有 0 或 1，绝对不是位操作的本意。这类“位操作想表达位拼接，结果误用了逻辑运算符”的错误，很难一眼看出，因为代码规模一大，视觉上很容易忽略 && 和 & 的区别。

所以我在写位运算相关代码时有个习惯：优先级不清楚就加一层括号，尤其是位运算和逻辑运算混用的时候。宁愿多写一个括号，也不愿意花两小时查一个需要读很久才能发现的 bug。

5.3 编译器优化级别改变后，未定义行为“现出原形”

这类问题最让人头疼。在 -O0 下代码表现正常，一开 -O2 结果突然变了。这种情况十有八九是未定义行为。

典型的例子：

c复制int i = 1;
int x = i++ + i++;

在 -O0 下，编译器可能按照直观顺序计算，两个 i++ 依次执行，结果 x 是 2，i 变成 3。但在 -O2 下，编译器可能做优化，结果完全不同。这种写法本身就是未定义行为，正确做法就是不要这么写。

按照 C 标准，同一表达式中对一个变量有多次副作用修改且没有序列点分隔，就会产生未定义行为。序列点包括分号、&&、||、?:、逗号运算符等处。所以 a = b++; c = b++; 是安全的，因为分号隔开了两个序列；但 x = b++ + b++; 就是未定义的。

这个知识点在面试中经常出现，因为它考察的是对 C 语言“副作用和序列点”概念的理解深度。光记优先级表还不够，还要理解“优先级不等于求值顺序”这个核心点。

5.4 常见优先级错误速查表

我把常见的优先级错误和正确写法整理成了一张表，方便你在实际编码时快速自查：

这张表涵盖了笔试面试中最高频的十几个陷阱场景。你可以把它当成自测题，先把右列盖住，看自己能不能写出正确的解析结果。

5.5 关于 sizeof 的一个易忽视细节

sizeof 的优先级在单目运算符这一层，它可以在不加括号的情况下直接作用于变量名，但作用于类型时必须加括号：

c复制int x;
sizeof x;      // 合法，作用于变量
sizeof(int);   // 合法，作用于类型时必须加括号
sizeof int;    // 语法错误

sizeof 和强转运算符属于同一优先级层，都是从右到左结合。这在实际代码中还有一个容易踩的坑：

c复制int *p = malloc(10 * sizeof(int));

这里 10 * sizeof(int) 中 sizeof 先作用，乘法后执行，因为单目运算符优先级高于乘法。如果你想分配 10 个 int* 的大小，要写成 10 * sizeof(int *)，注意别写成 sizeof(int *) * 10 也没问题，因为乘法交换律不改变结果。但有些人会写成 sizeof(int *) * 10 再 malloc，这也没错。

5.6 看老代码时的一个优先级速记法

阅读别人维护多年的 C 代码时，你经常会发现一些“省略了括号但逻辑正确”的表达式。这些表达式其实都在暗中遵守优先级规则。如果你不想每次都查表，我分享一个我自己用的速记顺序：

括号 > 单目 > 乘除 > 加减 > 移位 > 比较 > 位与 > 位异或 > 位或 > 逻辑与 > 逻辑或 > 三目 > 赋值 > 逗号

用一句话串起来：一个单目，算加减移，比等位，罗三赋逗。虽然不押韵，但每两个字的顺序对应一层优先级，能帮你在脑子里快速生成一条“优先级链”。遇到不确定的表达式，先画一个分层括号，再逐层判断，基本不会错。

还有一个小诀窍：看到赋值号，先看右边；看到逗号，先看整体。因为赋值优先级低，它的右边通常是一个完整的表达式；而逗号优先级最低，它通常会把前面所有内容整体拼接起来。

6. 从优先级到工程实践：括号该加还是不该加？

学完优先级之后，你会面临一个现实问题：写代码时到底要不要把括号写全？

我的看法是：不要把代码写得像个括号怪物，也不要为了避免括号而炫技。核心原则是“让意图清晰”。

在我自己主导的项目里，我要求的编码规范是：

• 凡是用到位运算且和比较、逻辑运算混用的，一律加括号；
• 凡是用到三目运算符嵌套的，一律拆开或加括号；
• 凡是指针解引用和自增自减混用的，必须保证自己和读者都能瞬间看出语义；
• 其余情况，遵循优先级表的自然顺序，不额外加多余的括号。

这背后的逻辑是：优先级表是 C 语言标准的一部分，合格的 C 程序员应该具备直接读懂标准表达式的能力。但工程代码不是考试题，它需要被大多数人高效地理解和维护。所以，在“可能引起误解”的地方主动加括号，是一种工程美德，而不是能力不足的表现。

举一个实际例子。判断某个指针是否为空且其指向的值大于 0：

c复制if (ptr && *ptr > 0) {
    // ...
}

这里 *ptr > 0 由于 * 优先级高于 >，等价于 (*ptr) > 0，没有歧义。为了可读性，也有人会写：

c复制if (ptr != NULL && (*ptr) > 0) {
    // ...
}

第一种写法更简洁，第二种写法更明确，两者都可接受。关键不是哪一种更好，而是你要知道为什么第一种写法是安全的，而不是稀里糊涂地“抄”过来用。

我在面试候选人的时候，很喜欢问一个问题：“这个 *p++ 到底是什么意思？”能答对的人不少，但能进一步解释“为什么是 *(p++) 而不是 (*p)++”的人就明显少了。这个“为什么”背后，就是优先级表的知识，以及理解和应用能力的差异。

7. 最后再分享两个小技巧

一个是我个人看代码时特别受用的习惯：遇到复杂表达式，先找最低优先级的运算符。因为整个表达式会被它从中间“切开”，形成左右两棵子树，然后再递归处理每个子树。比如 a * b + c 里，+ 优先级最低，所以表达式先被切为 (a * b) 和 c 两部分；a = b + c * d 里，= 优先级最低，所以右边整体是 b + c * d，再进一步拆。这样一层一层剥开，复杂的表达式就会被拆成简单的树形结构，阅读难度大大降低。

另一个小技巧是：如果你的 IDE 支持“显示解析树”或者“高亮匹配括号”，可以打开它作为辅助。很多现代编辑器在鼠标悬停表达式时会把对应子表达式高亮出来，这能帮你快速确认编译器是怎么拆解的。用它来验证自己的判断，几次之后你就形成了肌肉记忆。

C 语言的运算符确实多，但优先级体系本身是严密的、有规律的。它不是一堆零散规则，而是一张完整的表。搞清楚了这张表，再结合常见陷阱反复练习，运算符这一关就能稳稳过去。以后不管是写指针操作、位运算还是复杂判断逻辑，你都会有底气得多。