C语言运算符优先级速查表与规则：深度解析与实践指南
C语言，作为一种强大而灵活的编程语言，其核心在于能够对数据进行各种操作。这些操作通过运算符来完成。然而，在一个复杂的表达式中，可能包含多个不同的运算符，此时，程序必须遵循一套既定的规则来确定这些运算符的执行顺序。这套规则就是运算符优先级（Operator Precedence）和运算符结合性（Operator Associativity）。
理解C语言的运算符优先级和结合性是编写正确、可预测且易于维护代码的基础。错误的理解可能导致意外的计算结果，引入难以察觉的bug。本文将深入探讨C语言的运算符优先级和结合性规则，提供一个详细的速查表，并通过解释和示例帮助读者彻底掌握这些关键概念。
1. 什么是运算符优先级和结合性？为何如此重要？
想象一个数学表达式：2 + 3 * 4。根据小学数学知识，我们知道乘法应该先于加法执行。所以计算顺序是 3 * 4 = 12，然后 2 + 12 = 14。这个“乘法优先于加法”的规则就是运算符优先级的一种体现。
在C语言中，这个概念被推广到更多的运算符类型。当一个表达式中出现多个不同优先级的运算符时，优先级高的运算符会先执行。
但是，如果一个表达式中包含多个相同优先级的运算符呢？例如 10 - 5 - 2 或 a = b = c。这时就需要运算符结合性（Associativity）规则。结合性规定了相同优先级的运算符在没有括号明确指定的情况下，是按照从左到右（Left-to-Right）还是从右到左（Right-to-Left）的顺序分组执行。
- 对于
10 - 5 - 2，减法是左结合的，所以先计算10 - 5 = 5，然后5 - 2 = 3。 - 对于
a = b = c，赋值运算符是右结合的，所以先执行b = c（假设c=5），然后a = (b = 5)，最终a和b都变为5。
为何如此重要？
- 保证计算的正确性： 正确理解优先级和结合性是获得预期计算结果的根本。一个微小的误解就可能导致程序逻辑错误。
- 避免潜在的bug： 由运算符规则引起的错误往往比较隐蔽，可能在特定条件下才会显现，增加了调试难度。
- 理解现有代码： 阅读他人或旧的代码时，如果缺乏对优先级和结合性的了解，将难以理解复杂的表达式。
- 编写清晰的代码（通过合理使用括号）： 虽然掌握规则很重要，但在实际编程中，我们常常使用括号
()来显式地指定运算顺序，即使默认规则已经是对的。这大大提高了代码的可读性，降低了出错的可能性。括号具有最高的优先级，可以强制改变任何默认的运算顺序。
2. C语言运算符优先级速查表
下表列出了C语言中所有运算符的优先级和结合性。表格按照优先级从高到低的顺序排列（优先级越高，越先计算）。在同一行中的运算符具有相同的优先级，它们的执行顺序由结合性决定。
| 优先级 | 运算符 | 描述 | 结合性 |
|---|---|---|---|
| 1 | () [] -> . ++ (后缀) -- (后缀) |
圆括号 (函数调用, 表达式分组) 数组下标 成员访问 (指针) 成员访问 (结构体/联合) 后缀递增 后缀递减 |
左到右 |
| 2 | ! ~ + * & (type) sizeof ++ (前缀) -- (前缀) |
逻辑非 按位取反 一元正号 一元负号 解引用 (指针) 取地址 类型转换 计算类型或对象大小 前缀递增 前缀递减 |
右到左 |
| 3 | * / % |
乘法 除法 取模 |
左到右 |
| 4 | + - |
加法 减法 |
左到右 |
| 5 | << >> |
左移 右移 |
左到右 |
| 6 | < <= > >= |
小于 小于等于 大于 大于等于 |
左到右 |
| 7 | == != |
等于 不等于 |
左到右 |
| 8 | & |
按位与 | 左到右 |
| 9 | ^ |
按位异或 | 左到右 |
| 10 | | |
按位或 | 左到右 |
| 11 | && |
逻辑与 | 左到右 |
| 12 | || |
逻辑或 | 左到右 |
| 13 | ? : |
条件运算符 (三元运算符) | 右到左 |
| 14 | = += -= *= /= %= <<= >>= &= ^= |= |
赋值 复合赋值 |
右到左 |
| 15 | , |
逗号运算符 | 左到右 |
重要说明：
- 此表反映的是标准C语言（如C99、C11、C18）的规则。
- 后缀
++和--与前缀++和--虽然看起来相似，但在表达式中的优先级、结合性以及对操作数实际修改的时间点（与序列点相关，比优先级更深层次的概念）有所不同。后缀运算符的优先级高于前缀运算符，并且它们属于不同的优先级组。 - 一元运算符
+和-与二元运算符+和-是不同的运算符，它们在优先级上高于对应的二元版本。 - 解引用
*和取地址&是一元运算符，与乘法*和按位与&不同，它们具有更高的优先级。 - 逗号运算符
,在这里特指作为运算符使用的逗号，它用于分隔一系列表达式，并保证这些表达式按顺序从左到右执行，最终表达式的值是最后一个子表达式的值。它不同于在变量声明、函数参数列表或初始化列表中的分隔符逗号。
3. 详细解释各优先级组与规则
接下来，我们将详细解释每个优先级组内的运算符及其行为。
优先级 1：最高优先级（左结合）
这组包含的运算符通常用于访问对象成员、数组元素、函数调用以及后缀式的增减量操作。
()(圆括号): 用于函数调用（如myFunction(x)）或强制改变表达式的求值顺序（如(a + b) * c）。作为分组用途时，它具有最高的优先级。[](数组下标): 用于访问数组中的特定元素，如myArray[i]。->(成员访问，指针): 用于通过指向结构体或联合体的指针访问其成员，如ptr->member，等价于(*ptr).member（但优先级更高，避免了对*和.优先级的混淆）。.(成员访问，结构体/联合体): 用于通过结构体或联合体变量直接访问其成员，如myStruct.member。++(后缀递增): 如x++。表达式首先取x的当前值，然后x的值增加1。--(后缀递减): 如x--。表达式首先取x的当前值，然后x的值减少1。
例子:
arr[i].member++
解析：
1. [] 和 . 具有最高优先级且左结合，所以先处理 arr[i]，得到数组中索引为 i 的结构体/联合体。
2. 然后处理 .member，访问该结构体的 member 成员。
3. 最后处理后缀 ++。表达式的值是 arr[i].member 在递增之前的值，然后 arr[i].member 的值才会增加1。
优先级 2：一元运算符（右结合）
这组包含各种作用于单个操作数的一元运算符。它们的结合性是右到左，这意味着在一个表达式中连续出现多个一元运算符时，最右边的运算符会先作用于其操作数，然后左边的运算符依次作用于结果。
!(逻辑非): 对操作数进行逻辑非运算，结果为int类型。如果操作数非零，结果为0；如果操作数为零，结果为1。~(按位取反): 对操作数的每个位进行取反。+(一元正号): 表示操作数是正值。通常不起作用，但可以明确意图或用于类型提升。-(一元负号): 对操作数取负。*(解引用): 通过指针访问其指向的内存位置的值。如*ptr。&(取地址): 获取变量或表达式的内存地址。如&variable。(type)(类型转换): 将操作数强制转换为指定的类型。如(int)3.14。sizeof(大小运算符): 计算类型或变量在内存中占用的字节数。如sizeof(int)或sizeof(variable).++(前缀递增): 如++x。x的值先增加1，然后表达式取x新的值。--(前缀递减): 如--x。x的值先减少1，然后表达式取x新的值。
例子:
*ptr++ vs (*ptr)++ vs ++*ptr
*ptr++: 优先级最高的是后缀++，左结合，但此处只有它和*。根据优先级表，++(后缀，优先级1) 高于*(解引用，优先级2)。所以先将ptr的值（地址）“用于”表达式（即准备执行递增），然后获取ptr原地址指向的值 (*ptr)作为整个表达式的值，最后ptr的值递增（指向下一个元素）。这常用于遍历数组指针。(*ptr)++: 括号()强制了求值顺序。先执行*ptr，获取ptr指向的值。然后对这个值进行后缀递增。表达式的值是*ptr原来的值，然后*ptr指向的内存位置的值增加1。ptr本身不变。++*ptr: 优先级最高的是前缀++和*(同优先级2，右结合)。右结合意味着先处理右边的*ptr，得到ptr指向的值。然后对这个值进行前缀递增。表达式的值是*ptr递增后的新值，并且*ptr指向的内存位置的值增加1。ptr本身不变。
再如：! - x
解析：一元 - 和 ! 都属于优先级2，右结合。先处理 -x，然后对 -x 的结果进行逻辑非运算 !(-x)。
优先级 3：乘法、除法、取模（左结合）
标准的算术乘法、除法和取模运算。
*(乘法)/(除法)%(取模)
例子:
a * b / c % d
解析：都具有优先级3，左结合。计算顺序是 ((a * b) / c) % d。
优先级 4：加法、减法（左结合）
标准的算术加法和减法运算。
+(加法)-(减法)
例子:
a + b - c + d
解析：都具有优先级4，左结合。计算顺序是 (((a + b) - c) + d)。
结合优先级3和4的例子：a + b * c。乘法优先级高于加法，所以先计算 b * c，然后是 a + (b * c)。
优先级 5：位移运算符（左结合）
用于对操作数的位进行左移或右移。
<<(左移)>>(右移)
例子:
a << b >> c
解析：都具有优先级5，左结合。计算顺序是 (a << b) >> c。
结合优先级3, 4, 5的例子：a * 2 + b << 3
解析：优先级顺序是 * (3) -> + (4) -> << (5)。计算顺序是 (a * 2) + (b << 3)。
优先级 6：关系运算符（左结合）
用于比较两个操作数的大小。结果是 int 类型，满足条件为1，不满足为0。
<(小于)<=(小于等于)>(大于)>=(大于等于)
例子:
a > b && b < c
解析：优先级6 (>,<) 高于优先级11 (&&)。先计算 a > b 和 b < c，得到两个0或1的结果。然后将这两个结果进行逻辑与运算。
注意： 不要在同一个表达式中连续使用关系运算符来表达链式比较，如 a < b < c。这在数学上表示 a < b 并且 b < c，但在C语言中，由于左结合性，它被解析为 (a < b) < c。首先计算 a < b，结果是0或1，然后将这个0或1与 c 进行比较。这通常不是你想要的结果。正确的写法是 a < b && b < c。
优先级 7：相等运算符（左结合）
用于判断两个操作数是否相等。结果是 int 类型，相等为1，不相等为0。
==(等于)!=(不等于)
例子:
a == b != c
解析：优先级7 (==,!=) 高于优先级6。都具有优先级7，左结合。计算顺序是 (a == b) != c。先判断 a == b，结果是0或1。然后判断这个结果是否不等于 c。
结合优先级6和7的例子：a < b == c
解析：优先级7 (==) 高于优先级6 (<)。计算顺序是 a < (b == c)。先判断 b == c，结果是0或1。然后判断 a 是否小于这个结果。
优先级 8, 9, 10：按位逻辑运算符（左结合）
这三组是按位与、按位异或和按位或运算符，它们作用于操作数的每一个位。它们的优先级低于关系运算符和相等运算符，但高于逻辑运算符。
- 优先级 8:
&(按位与) - 优先级 9:
^(按位异或) - 优先级 10:
|(按位或)
例子:
a & b ^ c | d
解析：优先级顺序是 & (8) -> ^ (9) -> | (10)。它们都是左结合。计算顺序是 ((a & b) ^ c) | d。
结合其他运算符的例子：mask & value == 0
解析：优先级7 (==) 高于优先级8 (&)。计算顺序是 mask & (value == 0)。先判断 value == 0，结果是0或1，然后将 mask 与这个结果进行按位与操作。这与 (mask & value) == 0 是完全不同的。
优先级 11, 12：逻辑运算符（左结合）
这组是逻辑与和逻辑或运算符。它们作用于操作数的逻辑值（非零为真，零为假）。结果是 int 类型（1为真，0为假）。它们具有“短路求值”的特性。
- 优先级 11:
&&(逻辑与) - 优先级 12:
||(逻辑或)
逻辑与 (&&) 的短路特性： 如果 a && b 中 a 的值为假（0），则整个表达式的值一定为假，此时 b 不会被求值。
逻辑或 (||) 的短路特性： 如果 a || b 中 a 的值为真（非零），则整个表达式的值一定为真，此时 b 不会被求值。
例子:
condition1 && condition2 || condition3
解析：优先级11 (&&) 高于优先级12 (||)，两者都左结合。计算顺序是 (condition1 && condition2) || condition3。先评估 condition1 && condition2，然后将结果与 condition3 进行逻辑或运算。注意短路求值可能发生。
优先级 13：条件运算符（右结合）
条件运算符 ? : 是C语言中唯一的三元运算符。它根据第一个操作数（条件）的布尔值来选择执行第二个或第三个操作数。
condition ? expression1 : expression2
如果 condition 为真（非零），则整个表达式的值是 expression1 的值；否则，值是 expression2 的值。只有被选中的那个表达式会被求值。
例子:
int max = (a > b) ? a : b;
解析：括号内的 a > b 先计算，然后根据结果选择 a 或 b 的值赋给 max。条件运算符的优先级相对较低，通常会先计算其操作数。它是右结合的，这在使用嵌套条件运算符时很重要，尽管嵌套通常不推荐以提高可读性。
例如：a > b ? x : y > c ? y : z
解析（右结合）：a > b ? x : (y > c ? y : z)。如果 a > b 为真，结果是 x。如果为假，则评估 y > c ? y : z。
优先级 14：赋值运算符（右结合）
这组包括简单的赋值运算符 = 以及复合赋值运算符，如 +=、-=、*= 等。
=(赋值)+=-=*=/=%=<<=>>=&=^=|=(复合赋值)
赋值运算符的特点是右结合性。在一个表达式中连续出现赋值运算符时，它们从右向左执行。赋值表达式的值是赋给左操作数的值。
例子:
a = b = c = 0;
解析：优先级14，右结合。计算顺序是 a = (b = (c = 0))。
1. c = 0: 将0赋给 c。表达式 c = 0 的值是0。
2. b = (c = 0): 将上面表达式的值（0）赋给 b。表达式 b = (c = 0) 的值是0。
3. a = (b = (c = 0)): 将上面表达式的值（0）赋给 a。表达式 a = (b = (c = 0)) 的值是0。
最终，a, b, c 的值都是0。
复合赋值运算符如 a += b 等价于 a = a + b，但它是一个单独的运算符，优先级与简单赋值 = 相同，结合性也是右到左。
例子:
a = b *= 2;
解析：优先级14，右结合。计算顺序是 a = (b *= 2)。
1. b *= 2: 将 b 的值乘以2，然后赋回给 b。表达式 b *= 2 的值是新的 b 的值。
2. a = (b *= 2): 将新的 b 的值赋给 a。
优先级 15：逗号运算符（左结合）
逗号运算符 , 用于将多个表达式组合成一个表达式。这些子表达式会按照从左到右的顺序依次求值。整个逗号表达式的值是最右边那个子表达式的值。
例子:
int x = (a++, b++, c);
解析：括号内的逗号运算符（优先级15，左结合）。
1. a++: a 的值用于表达式，然后 a 递增。
2. b++: b 的值用于表达式，然后 b 递增。
3. c: c 的值被求得。
整个表达式 (a++, b++, c) 的值是 c 的值，这个值赋给了 x。注意 a 和 b 的递增是在整个赋值完成之前发生的。
逗号运算符常用于 for 循环的初始化或更新部分：
for (i = 0, j = 10; i < j; i++, j--) { ... }
重要提醒： 逗号在不同上下文中有不同作用。在变量声明（int a, b;）、函数参数列表（func(x, y);）或初始化列表（int arr[] = {1, 2};）中，逗号是分隔符，不是运算符，不遵循这里的优先级和结合性规则。只有在表达式中连接子表达式时，它才是逗号运算符。
4. 使用括号 () 改变优先级和提高可读性
圆括号 () 作为分组运算符时，具有最高的优先级（优先级1）。这意味着任何被括号括起来的子表达式都会被优先计算。这是程序员强制指定运算顺序的最常用和最可靠的方式。
例子：
a + b * c：根据优先级，先乘后加，等价于a + (b * c)。(a + b) * c：括号改变了顺序，先加后乘。
使用括号不仅可以确保计算顺序符合预期，还能极大地提高代码的可读性。即使在优先级规则明确的情况下，如果表达式比较复杂，使用括号也能帮助阅读者快速理解作者的意图，避免查表的麻烦。
建议： 当你不确定或觉得表达式难以理解时，大胆使用括号。宁可多加几个括号，也不要因优先级问题引入bug。
5. 常见陷阱与最佳实践
- 混淆一元/二元运算符：
*可以是解引用或乘法，&可以是取地址或按位与，+/-可以是一元正负或二元加减。它们的优先级不同。 - 混淆按位逻辑与逻辑运算符：
&(按位与) 和&&(逻辑与) 是不同的运算符，优先级也不同 (&&优先级低于&)，行为（逐位 vs 短路求值）也完全不同。同理，|(按位或) 和||(逻辑或) 也不同。 - 链式比较： 如前所述，
a < b < c不等于a < b && b < c。 - 复杂的副作用表达式： 在同一个表达式中多次修改同一个变量（如
i++ * i++）或在依赖变量的表达式中同时修改变量（如arr[i++] = i;）可能导致未定义行为。虽然这与优先级和结合性不是同一个概念（更接近于C语言的序列点规则），但复杂的表达式往往会结合运算符优先级的问题，使得行为更加难以预测。应尽量避免此类写法。 - 过度依赖规则： 死记硬背完整的优先级表不如理解主要的优先级分组和结合性，并在必要时查阅或使用括号。
- 可读性： 过于紧凑的表达式，即使优先级正确，也可能难以阅读和理解。将复杂的表达式分解成多个步骤或使用临时变量是提高可读性的好方法。
最佳实践：
- 了解核心优先级： 掌握基本的算术、关系、逻辑、赋值运算符的相对优先级。
- 理解结合性： 特别注意赋值运算符和一元运算符的右结合性，以及其他大多数运算符的左结合性。
- 善用括号： 对于复杂的表达式，或者当你拿不准优先级时，使用括号来明确指定运算顺序。这极大地提高了代码的清晰度和健壮性。
- 避免过于复杂的表达式： 将复杂的逻辑分解成更小的、易于管理的表达式。
- 警惕副作用： 在包含
++、--或赋值运算符的复杂表达式中要特别小心，理解何时值被使用以及何时变量被修改。
6. 总结
C语言的运算符优先级和结合性规则是语言规范中不可或缺的部分，它们共同决定了复杂表达式的求值顺序。通过本文提供的速查表和详细解释，我们希望帮助读者建立起对这些规则清晰的认识。
记住，优先级决定了不同运算符之间的执行顺序，而结合性决定了相同优先级运算符的分组方式。掌握这些规则是编写正确C代码的基础。然而，在实际编程中，为了代码的清晰和可维护性，强烈推荐优先使用括号来明确你的意图，而不是过度依赖复杂的优先级规则。清晰的代码不仅不容易出错，也更容易被他人（或未来的自己）理解和修改。
将本文的速查表作为一个方便的参考，并在实践中不断巩固对这些规则的理解。通过编写、测试和调试代码，你将能够熟练地运用C语言的运算符，写出高效且可靠的程序。