掌握C语言运算符优先级：入门指南
欢迎来到C语言的世界！编程不仅仅是将一系列指令写下来，更在于让计算机按照我们预期的顺序执行这些指令。在C语言中，运算符（Operators）是执行各种操作的符号，比如加减乘除、比较大小、逻辑判断等等。然而，当一个表达式中包含多个运算符时，计算机如何决定先执行哪个操作呢？这就引出了C语言中一个至关重要的概念：运算符优先级（Operator Precedence）和运算符结合性（Operator Associativity）。
理解并掌握运算符的优先级和结合性，是编写出正确、可预测、并且易于理解的C代码的基础。忽视它们，轻则导致计算结果错误，重则引入难以排查的逻辑错误（Bug）。本篇文章将带你深入了解C语言运算符的优先级和结合性，从基础概念出发，结合丰富的示例，帮助你彻底掌握这一关键技能。
1. 什么是运算符优先级和结合性？为什么它们如此重要？
想象一下数学中的表达式：5 + 3 * 2。如果你从左到右简单计算，会得到 (5 + 3) * 2 = 8 * 2 = 16。但根据数学规则（乘法优先于加法），正确的计算顺序是 5 + (3 * 2) = 5 + 6 = 11。这里的“乘法优先于加法”就是一种优先级规则。
在C语言中，也存在类似的规则。当一个表达式中有多个不同的运算符时，运算符优先级决定了哪个运算符先被执行。优先级高的运算符会先于优先级低的运算符执行。
那么，如果一个表达式中有多个具有相同优先级的运算符呢？例如 10 - 5 - 2 或者 20 / 4 * 2。这时，运算符结合性（或称关联性）就起作用了。结合性规定了相同优先级的运算符是从左到右执行，还是从右到左执行。
- 对于
10 - 5 - 2，减法是左结合的，所以计算顺序是(10 - 5) - 2 = 5 - 2 = 3。 - 对于
20 / 4 * 2，乘法和除法优先级相同，且都是左结合的，所以计算顺序是(20 / 4) * 2 = 5 * 2 = 10。 - 对于赋值运算符
=，它是右结合的。例如a = b = c，其计算顺序是a = (b = c)，先将c的值赋给b，再将b（现在包含c的值）赋给a。
为什么它们如此重要？
- 确保计算结果的正确性： 这是最直接的原因。错误的优先级或结合性理解会导致代码产生非预期的结果。
- 提高代码的可预测性： 了解这些规则，你能准确地预判代码的行为，减少意外发生。
- 编写清晰易懂的代码： 虽然可以通过括号来强制执行顺序（后面会讲到），但理解默认规则有助于你更好地组织代码，并且在阅读他人代码时也能快速理解其意图（即使他们使用了默认规则而没有加括号）。
- 避免潜在的Bug： 许多难以发现的逻辑错误往往与对运算符优先级或结合性的误解有关，尤其是在涉及位运算符和逻辑运算符的复杂表达式中。
因此，掌握优先级和结合性是C语言入门进阶的必经之路。
2. C语言运算符优先级表
C语言标准定义了明确的运算符优先级和结合性规则。下表列出了C语言中主要的运算符，按照优先级从高到低排列。在同一行中的运算符具有相同的优先级，它们的执行顺序由结合性决定。
| 优先级 | 运算符 | 描述 | 结合性 |
|---|---|---|---|
| 1 | () [] -> . |
括号、数组下标、成员访问 | 左到右 |
| 2 | ! ~ ++ -- + (unary) - (unary) * (dereference) & (address) sizeof (type) |
逻辑非、按位非、自增、自减、一元加/减、解引用、取地址、类型大小、类型转换 | 右到左 |
| 3 | * / % |
乘、除、取模 | 左到右 |
| 4 | + - |
加、减 | 左到右 |
| 5 | << >> |
位左移、位右移 | 左到右 |
| 6 | < <= > >= |
小于、小于等于、大于、大于等于 | 左到右 |
| 7 | == != |
等于、不等于 | 左到右 |
| 8 | & (bitwise) |
按位与 | 左到右 |
| 9 | ^ (bitwise) |
按位异或 | 左到右 |
| 10 | | (bitwise) |
按位或 | 左到右 |
| 11 | && |
逻辑与 | 左到右 |
| 12 | || |
逻辑或 | 左到右 |
| 13 | ? : |
条件运算符（三元） | 右到左 |
| 14 | = += -= *= /= %= <<= >>= &= ^= |= |
赋值运算符 | 右到左 |
| 15 | , |
逗号运算符 | 左到右 |
如何阅读和使用这张表：
- 行号越小，优先级越高。 例如，优先级1的括号
()最高，优先级15的逗号,最低。 - 在同一行中，运算符优先级相同。
- 结合性决定了同一优先级运算符的执行顺序：
- 左到右（Left-to-Right）： 从表达式的左边开始向右边依次执行。
- 右到左（Right-to-Left）： 从表达式的右边开始向左边依次执行。
接下来，我们将通过具体的例子来详细解释表中各个优先级的运算符。
3. 详细解析各优先级运算符（带示例）
为了更好地理解，我们将按照优先级从高到低进行讲解。
优先级 1: 括号 ()、数组下标 []、结构体成员访问 -> 和 .
这些是最高优先级的运算符，它们主要用于改变默认的求值顺序或访问复合类型成员。
()(括号): 用于分组表达式，强制先计算括号内的部分。这是最常用的改变优先级的手段。
c
int a = 5, b = 3, c = 2;
int result1 = a + b * c; // 乘法先执行: 5 + (3 * 2) = 11
int result2 = (a + b) * c; // 括号先执行: (5 + 3) * 2 = 16
printf("Result 1: %d\n", result1); // 输出 11
printf("Result 2: %d\n", result2); // 输出 16[](数组下标): 用于访问数组中的元素。
c
int arr[] = {10, 20, 30};
int value = arr[1]; // 访问索引为1的元素，即20
printf("Array element: %d\n", value); // 输出 20.和->(结构体成员访问): 用于访问结构体或联合体的成员。.用于直接访问，->用于通过指针访问。
c
struct Point {
int x;
int y;
};
struct Point p1 = {1, 2};
struct Point *p_ptr = &p1;
int x_coord1 = p1.x; // 通过 . 访问
int x_coord2 = p_ptr->x; // 通过 -> 访问 (等价于 (*p_ptr).x)
printf("X coordinates: %d, %d\n", x_coord1, x_coord2); // 输出 1, 1
这些运算符优先级很高，意味着在表达式中它们会先于大多数其他运算符进行求值。例如ptr->member++，由于->优先级高于++（自增/自减在优先级2，但这里是后缀形式，先使用值再自增），所以先访问ptr->member，然后对该成员的值进行自增。
优先级 2: 一元运算符 (!, ~, ++, --, +, -, *, &, sizeof, (type))
这一组是一元运算符，它们只作用于一个操作数。注意，这里的 + 和 - 是正号和负号，与优先级4的加减法不同。* 是解引用，& 是取地址，与优先级3的乘法和优先级8的按位与也不同。
!(逻辑非): 对布尔值（0表示假，非0表示真）取反。
c
int cond = 5;
int not_cond = !cond; // !5 等于 !真，结果为 0 (假)
printf("!5 is %d\n", not_cond); // 输出 0~(按位非): 对整数的二进制位取反。
c
unsigned int num = 5; // 二进制 000...0101
unsigned int inverted_num = ~num; // 二进制 111...1010 (取决于整数大小)
printf("~5 is %u\n", inverted_num);-
++和--(自增/自减): 可以放在操作数前面（前缀）或后面（后缀）。- 前缀 (
++x,--x): 先改变变量的值，再使用改变后的值。 - 后缀 (
x++,x--): 先使用变量当前的值，再改变变量的值。
“`c
int x = 10;
int y = 5 + ++x; // x先变成11，然后 5 + 11 = 16。y=16, x=11
printf(“y = %d, x = %d\n”, y, x); // 输出 y = 16, x = 11
x = 10;
y = 5 + x++; // 先计算 5 + 10 = 15，然后x变成11。y=15, x=11
printf(“y = %d, x = %d\n”, y, x); // 输出 y = 15, x = 11
`++` 和 `--` 与其他运算符结合时，优先级非常重要。例如 `*p++`。`*` 是解引用，`++` 是后缀自增。虽然它们优先级相同（都是2），但结合性是右到左。所以 `*p++` 实际上是 `*(p++)`。`p++` 会先使用 `p` 的当前地址值，然后 `p` 的地址值自增。`*` 则作用于 `p` 的**原始**地址值。结果是：先取 `p` 指向的地址的值，然后 `p` 指针向后移动一个其所指向类型的大小。这是一个非常常见且重要的用法。c
* **`+` (一元加) 和 `-` (一元减):** 表示正号和负号。
int num = 10;
int positive = +num; // 相当于 num
int negative = -num; // 取负
printf(“Positive: %d, Negative: %d\n”, positive, negative); // 输出 10, -10
* **`*` (解引用):** 用于访问指针指向的内存地址中的值。c
int value = 100;
int ptr = &value;
int dereferenced_value = ptr; // 获取 ptr 指向的值 (100)
printf(“Dereferenced value: %d\n”, dereferenced_value); // 输出 100
* **`&` (取地址):** 用于获取变量的内存地址。c
int value = 100;
int ptr = &value; // ptr 存储 value 的地址
printf(“Address of value: %p\n”, (void )ptr); // 输出 value 的内存地址
* **`sizeof`:** 计算类型或变量的大小（以字节为单位）。c
int size_int = sizeof(int);
double d;
int size_double = sizeof(d);
printf(“Size of int: %d, Size of double: %d\n”, size_int, size_double);
* **`(type)` (类型转换):** 将一个值转换为指定的类型。c
double pi = 3.14;
int rounded_pi = (int)pi; // 将 double 转换为 int (截断小数部分)
printf(“Rounded pi: %d\n”, rounded_pi); // 输出 3
“` - 前缀 (
这一组运算符的结合性是右到左。例如 -!a 的计算顺序是 - (!a)。
优先级 3: 乘性运算符 (*, /, %)
包括乘法、除法和取模（求余数）。它们的优先级高于加减法。
*(乘法):/(除法): 整数相除会截断小数部分。%(取模): 仅适用于整数，返回除法的余数。
结合性是左到右。
“`c
int a = 10, b = 5, c = 2;
int result = a + b * c; // 乘法先于加法: 10 + (5 * 2) = 20
printf(“Result 1: %d\n”, result); // 输出 20
result = a / b * c; // 优先级相同，左结合: (10 / 5) * 2 = 2 * 2 = 4
printf(“Result 2: %d\n”, result); // 输出 4
result = a % c; // 10 除以 2 余 0
printf(“Result 3: %d\n”, result); // 输出 0
“`
优先级 4: 加性运算符 (+, -)
包括加法和减法。它们的优先级低于乘性运算符。结合性是左到右。
c
int a = 10, b = 5, c = 2;
int result = a - b + c; // 优先级相同，左结合: (10 - 5) + 2 = 5 + 2 = 7
printf("Result: %d\n", result); // 输出 7
结合优先级3和4：a + b * c - d / e 会先计算 b * c 和 d / e，然后从左到右计算加减法。
优先级 5: 移位运算符 (<<, >>)
用于对整数的二进制位进行左移或右移。
<<(左移): 将左操作数的二进制位向左移动右操作数指定的位数。左边移出的位丢弃，右边补0。>>(右移): 将左操作数的二进制位向右移动右操作数指定的位数。右边移出的位丢弃。对于无符号数，左边补0；对于有符号数，左边补0或补符号位（取决于实现，通常是补符号位）。
结合性是左到右。
“`c
unsigned int num = 10; // 二进制 000…1010
int result = num << 2; // 左移2位: 000…101000 (40)
printf(“10 << 2 is %d\n”, result); // 输出 40
result = num >> 1; // 右移1位: 000…0101 (5)
printf(“10 >> 1 is %d\n”, result); // 输出 5
// 示例与优先级3/4结合
int a = 5, b = 2;
result = a + b << 1; // 加法优先级高于移位: (5 + 2) << 1 = 7 << 1 = 14
printf(“5 + 2 << 1 is %d\n”, result); // 输出 14
result = a << b + 1; // 加法优先级高于移位: 5 << (2 + 1) = 5 << 3 = 40
printf(“5 << 2 + 1 is %d\n”, result); // 输出 40
“`
优先级 6: 关系运算符 (<, <=, >, >=)
用于比较两个值的大小。结果为布尔值（在C语言中用整数表示，非0为真，0为假）。
结合性是左到右。
“`c
int a = 10, b = 5;
int result = a > b; // 10 > 5 为真 (非0，通常为1)
printf(“10 > 5 is %d\n”, result); // 输出 1
result = a <= b; // 10 <= 5 为假 (0)
printf(“10 <= 5 is %d\n”, result); // 输出 0
// 示例与优先级3/4/5结合
result = a + b > c; // 加法优先级高于关系运算: (10 + 5) > c -> 15 > c
// 假设 c=12
result = 15 > 12; // 真 (1)
printf(“10 + 5 > 12 is %d\n”, result); // 输出 1
“`
优先级 7: 相等性运算符 (==, !=)
用于比较两个值是否相等或不相等。结果为布尔值。
==(等于):!=(不等于):
结合性是左到右。优先级低于关系运算符。
“`c
int a = 10, b = 5, c = 10;
int result = a == b; // 10 == 5 为假 (0)
printf(“10 == 5 is %d\n”, result); // 输出 0
result = a == c; // 10 == 10 为真 (1)
printf(“10 == 10 is %d\n”, result); // 输出 1
result = a != b; // 10 != 5 为真 (1)
printf(“10 != 5 is %d\n”, result); // 输出 1
// 示例与优先级6结合
result = a > b == c > b; // 关系运算符优先级更高
// a > b (10 > 5) 为真 (1)
// c > b (10 > 5) 为真 (1)
// 然后进行相等性比较: 1 == 1 为真 (1)
printf(“10 > 5 == 10 > 5 is %d\n”, result); // 输出 1
result = a > b == c; // 关系运算符优先级更高
// a > b (10 > 5) 为真 (1)
// 然后进行相等性比较: 1 == c (假设c=10) -> 1 == 10 为假 (0)
printf(“10 > 5 == 10 is %d\n”, result); // 输出 0
``a > b == c
注意上面最后一个例子。许多初学者可能会误以为是先比较a > b，再比较b == c，最后比较这两个结果。但实际上，由于>和==的优先级不同，它被解析为(a > b) == c。这是**非常常见且危险的错误来源**！如果你想表达的是“a>b并且b==c”，应该使用逻辑与&&`。
优先级 8: 按位与 (&)
用于对两个整数的二进制位进行“与”操作。同位都为1结果才为1，否则为0。
结合性是左到右。优先级低于相等性运算符。
“`c
int a = 5; // 二进制 0101
int b = 3; // 二进制 0011
int result = a & b; // 0101 & 0011 = 0001 (1)
printf(“5 & 3 is %d\n”, result); // 输出 1
// 常见错误示例与优先级7结合
result = a & 1 == 1; // 相等性运算符优先级高于按位与！
// 实际解析为 a & (1 == 1)
// (1 == 1) 为真 (1)
// 表达式变为 a & 1 (5 & 1) = 0101 & 0001 = 0001 (1)
printf(“5 & 1 == 1 (correct parsing) is %d\n”, result); // 输出 1
// 如果你想检查最低位是否为1，正确的写法是 (a & 1) == 1 或者 a & 1 (因为非0即真)
result = (a & 1) == 1; // 0101 & 0001 = 0001 (1)。 1 == 1 为真 (1)
printf(“(5 & 1) == 1 is %d\n”, result); // 输出 1
``&
**注意：**按位与和逻辑与&&是不同的运算符，它们有不同的优先级 (&优先级8，&&` 优先级11)。这是一个常见的混淆点。
优先级 9: 按位异或 (^)
用于对两个整数的二进制位进行“异或”操作。同位不同结果为1，否则为0。
结合性是左到右。优先级低于按位与。
c
int a = 5; // 二进制 0101
int b = 3; // 二进制 0011
int result = a ^ b; // 0101 ^ 0011 = 0110 (6)
printf("5 ^ 3 is %d\n", result); // 输出 6
优先级 10: 按位或 (|)
用于对两个整数的二进制位进行“或”操作。同位只要有一个为1结果就为1，否则为0。
结合性是左到右。优先级低于按位异或。
“`c
int a = 5; // 二进制 0101
int b = 3; // 二进制 0011
int result = a | b; // 0101 | 0011 = 0111 (7)
printf(“5 | 3 is %d\n”, result); // 输出 7
// 常见错误示例与优先级7结合
result = a | 1 == 1; // 相等性运算符优先级高于按位或！
// 实际解析为 a | (1 == 1)
// (1 == 1) 为真 (1)
// 表达式变为 a | 1 (5 | 1) = 0101 | 0001 = 0101 (5)
printf(“5 | 1 == 1 (correct parsing) is %d\n”, result); // 输出 5
// 如果你想检查某个位是否为1，正确的写法通常是通过按位与
// 例如，检查第0位是否为1: (a & 1) == 1 或者 a & 1
// 如果你想将某个位设置为1，可以使用按位或
// 例如，将第0位设置为1: a = a | 1; // 5 | 1 -> 5 (因为最低位已经是1)
``|
**注意：**按位或和逻辑或||是不同的运算符，它们有不同的优先级 (|优先级10，||` 优先级12)。这也是一个常见的混淆点。
优先级 11: 逻辑与 (&&)
用于连接两个布尔表达式。只有当两个表达式都为真（非0）时，结果才为真（非0）。
结合性是左到右。优先级低于按位或。
“`c
int a = 5, b = 0, c = 10;
int result = a > 0 && b > 0; // (5 > 0) && (0 > 0) -> 真 && 假 -> 假 (0)
printf(“a > 0 && b > 0 is %d\n”, result); // 输出 0
result = a > 0 && c > 0; // (5 > 0) && (10 > 0) -> 真 && 真 -> 真 (1)
printf(“a > 0 && c > 0 is %d\n”, result); // 输出 1
``&&
**短路求值（Short-circuit Evaluation）：**运算符具有短路求值特性。如果左边的表达式为假（0），整个&&` 表达式的结果就确定为假，右边的表达式将不再求值。
c
int x = 0, y = 10;
// 这里的 y++ 不会被执行，因为 x != 0 为假，整个 && 表达式已经确定为假
if (x != 0 && y++ > 5) {
// 这段代码不会执行
}
printf("After short-circuit: y = %d\n", y); // 输出 y = 10
这个特性在某些情况下非常有用，比如检查指针是否为空后再解引用：if (ptr != NULL && *ptr > 0)。如果 ptr 是 NULL，则 *ptr > 0 不会被求值，避免了程序崩溃。
优先级 12: 逻辑或 (||)
用于连接两个布尔表达式。只要当两个表达式中至少有一个为真（非0）时，结果就为真（非0）。
结合性是左到右。优先级低于逻辑与。
“`c
int a = 5, b = 0, c = 10;
int result = a > 0 || b > 0; // (5 > 0) || (0 > 0) -> 真 || 假 -> 真 (1)
printf(“a > 0 || b > 0 is %d\n”, result); // 输出 1
result = b > 0 || c < 5; // (0 > 0) || (10 < 5) -> 假 || 假 -> 假 (0)
printf(“b > 0 || c < 5 is %d\n”, result); // 输出 0
``||
**短路求值：**运算符也具有短路求值特性。如果左边的表达式为真（非0），整个||` 表达式的结果就确定为真，右边的表达式将不再求值。
c
int x = 1, y = 10;
// 这里的 y++ 不会被执行，因为 x == 1 为真，整个 || 表达式已经确定为真
if (x == 1 || y++ > 5) {
printf("Inside if\n"); // 这段代码会执行
}
printf("After short-circuit: y = %d\n", y); // 输出 y = 10
优先级 13: 条件运算符 (? :)
这是C语言唯一的三元运算符（因为它有三个操作数）。格式是 condition ? value_if_true : value_if_false。如果 condition 为真（非0），表达式的结果是 value_if_true；否则，结果是 value_if_false。
结合性是右到左。优先级低于逻辑或。
“`c
int a = 10, b = 5;
int max = (a > b) ? a : b; // (a > b) 为真，结果是 a 的值
printf(“Max is %d\n”, max); // 输出 10
int min = (a < b) ? a : b + 1; // (a < b) 为假，结果是 b + 1 的值。
// b + 1 的计算先于 ?: 返回值，但 ?: 的求值顺序决定了是 b+1 还是 a 被求值。
// 在这里，b+1 会被求值。
printf(“Min related calculation is %d\n”, min); // 输出 6
``a ? b : c ? d : e
由于条件运算符是右结合的，例如会被解析为a ? b : (c ? d : e)`。
优先级 14: 赋值运算符 (=, +=, -=, *=, /=, %=, <<=, >>=, &=, ^=, |=)
包括简单的赋值运算符 = 和复合赋值运算符（如 += 等）。
结合性是右到左。优先级非常低，仅高于逗号运算符。
“`c
int a, b, c;
a = b = c = 10; // 右结合: a = (b = (c = 10))
// 先 c = 10 (c变成10)，表达式 c=10 的结果是 10
// 再 b = 10 (b变成10)，表达式 b=10 的结果是 10
// 最后 a = 10 (a变成10)
printf(“a=%d, b=%d, c=%d\n”, a, b, c); // 输出 a=10, b=10, c=10
int x = 5;
x += 3; // 等价于 x = x + 3;
printf(“x after += 3 is %d\n”, x); // 输出 8
``a = b + c;
赋值运算符的优先级低于大多数其他运算符，这使得像这样的表达式能够正确地先计算b + c` 的结果，再进行赋值。
优先级 15: 逗号运算符 (,)
逗号运算符用于分隔表达式。它从左到右依次计算其操作数，并返回最右边操作数的值。
结合性是左到右。优先级最低。
c
int a = 1, b = 2, c = 3;
int result = (a++, b++, c++); // 逗号运算符从左到右计算 a++, b++, c++
// a++ -> a=2, 结果为 1
// b++ -> b=3, 结果为 2
// c++ -> c=4, 结果为 3
// 整个表达式的结果是最后一个操作数 c++ 的结果，即 3
printf("a=%d, b=%d, c=%d, result=%d\n", a, b, c, result); // 输出 a=2, b=3, c=4, result=3
注意，逗号运算符和函数调用时用于分隔参数的逗号是不同的。函数调用中的逗号不是运算符，它只是一种分隔符。
4. 使用括号强制执行顺序
如前所述，圆括号 () 具有最高的优先级。你可以使用括号来覆盖默认的优先级规则，或者仅仅是为了让代码更清晰。
“`c
int a = 5, b = 3, c = 2;
int result1 = a + b * c; // 乘法优先: 5 + (3 * 2) = 11
int result2 = (a + b) * c; // 括号改变优先级: (5 + 3) * 2 = 16
int flags = 5; // 二进制 0101
// 错误！== 优先级高于 &
if (flags & 4 == 4) { // 解析为 flags & (4 == 4) -> flags & 1 -> 5 & 1 -> 1 (真)
printf(“This might not be what you intended.\n”);
}
// 正确！使用括号强制先进行按位与
if ((flags & 4) == 4) { // 解析为 (flags & 4) == 4 -> (0101 & 0100) == 4 -> 0100 == 4 -> 4 == 4 (真)
printf(“This is the correct way to check the bit.\n”);
}
“`
即使你确定默认优先级是正确的，使用括号有时也能提高代码的可读性，让意图更加明显，特别是对于优先级不是非常直观的运算符组合（如位运算符、逻辑运算符和关系运算符混合）。
5. 常见的优先级混淆点和建议
- 位运算符 (
&,^,|) 与逻辑运算符 (&&,||): 这是最常见的混淆点之一。位运算符的优先级高于逻辑运算符，但低于关系运算符和相等性运算符。逻辑运算符优先级非常低。a & 1 == 1解析为a & (1 == 1)。a || b && c解析为a || (b && c)。
记住它们的相对位置：关系/相等性 > 位运算 > 逻辑运算。
- 赋值运算符的右结合性：
a = b = c;是a = (b = c);。 - 自增/自减运算符的前缀和后缀形式： 后缀形式 (
x++) 优先使用值，然后自增；前缀形式 (++x) 优先自增，然后使用值。与解引用结合时*p++(通常指*(p++)) 和(*p)++是不同的。 - 一元运算符和二元运算符的同符号问题：
-(负号) 和-(减号)、*(解引用) 和*(乘法)、&(取地址) 和&(按位与) 是不同的运算符，优先级也不同。编译器会根据上下文判断是哪种运算符。
建议：
- 查表： 在不确定时，随时查阅运算符优先级表。熟练掌握这张表是关键。
- 使用括号： 对于包含多种运算符的复杂表达式，或者当你对优先级没有百分百把握时，大胆使用括号来明确求值顺序。这不仅能确保代码正确性，更能显著提高代码的可读性，让其他开发者（包括未来的你）更容易理解你的意图。
- 避免过于复杂的表达式： 一个表达式中包含太多不同的运算符会让人难以理解。如果表达式变得非常复杂，考虑将其分解成几个更简单、更容易理解的步骤，使用临时变量存储中间结果。
- 理解结合性： 特别是对于连续的相同优先级运算符（如
a - b - c）和赋值运算符（a = b = c），理解它们的结合性是必要的。
6. 总结
C语言运算符优先级和结合性是编写正确程序的基石。优先级决定了不同运算符的执行顺序，而结合性决定了相同优先级运算符的执行顺序。
| 概念 | 作用 | 如何确定 | 强制改变方法 |
|---|---|---|---|
| 优先级 | 哪个运算符先执行（不同运算符） | 查阅优先级表（高优先级先执行） | 使用括号 () |
| 结合性 | 哪个运算符先执行（相同优先级运算符） | 查阅优先级表（左到右或右到左） | 使用括号 () |
掌握运算符优先级，理解结合性的规则，并善于使用括号来明确表达式的求值顺序，将帮助你写出更健壮、更易读、更少Bug的C语言代码。不要试图死记硬背所有规则，而是理解其原理，并在实践中多查阅、多运用。随着经验的积累，你会越来越熟悉这些规则，最终达到“掌握”的境界。
现在，你已经拥有了掌握C语言运算符优先级的入门知识。开始练习吧！尝试编写一些包含不同运算符的表达式，预测它们的执行结果，然后运行代码验证你的预测。祝你编程愉快！