19 C 语言位运算、赋值、条件、逗号运算符详解：涵盖运算符优先级与复杂表达式计算过程分析
1 位运算符
位运算符是对整数的二进制表示（补码形式）进行逐位操作的运算符。以下是主要的位运算符及其功能描述：
| 运算符 | 描述 | 操作数个数 | 副作用 |
|---|---|---|---|
| & | 按位与 | 2 | 无 |
| | | 按位或 | 2 | 无 |
| ^ | 按位异或 | 2 | 无 |
| ~ | 按位取反 | 1 | 无 |
| << | 按位左移 | 2 | 无 |
| >> | 按位右移 | 2 | 无 |
1.1 按位与 &
- 运算规则：对于两个数的每一位，如果两个相应的位都为 1，则结果的该位为 1；否则，结果的该位为 0（遵循 “有 0 为 0，全 1 为 1” 规则）。
- 示例：5 & 3
- 5 的二进制表示：0101
- 3 的二进制表示：0011
- 按位与操作过程：
0 1 0 1
& 0 0 1 1 ------- 0 0 0 1结果：0001（十进制1）1.2 按位或 |
- 运算规则：对于两个数的每一位，如果两个相应的位中至少有一个为 1，则结果的该位为 1；如果两个相应的位都为 0，则结果的该位为 0（遵循 “有 1 为 1，全 0 为 0” 规则）。
- 示例：5 | 3
- 5 的二进制表示：0101
- 3 的二进制表示：0011
- 按位或操作过程：
0 1 0 1
| 0 0 1 1 ------- 0 1 1 1结果：0111（十进制7）1.3 按位异或 ^
- 计算规则：对于两个数的每一位，如果两个相应的位不同（一个为 1，另一个为 0），则结果的该位为 1；如果两个相应的位相同（都为 0 或都为 1），则结果的该位为 0。（遵循 “相同为 0，不同为 1” 规则）。
- 示例：5 ^ 3
- 5 的二进制表示：0101
- 3 的二进制表示：0011
- 按位异或操作过程：
0 1 0 1
^ 0 0 1 1 ------- 0 1 1 0结果：0110（十进制6）为了清晰展示 8 位二进制数的位运算过程，我们可以使用 char 类型来进行按位与、按位或和异或操作的演示。由于 char 类型通常占用 8 位，非常适合作为位运算的示例载体。程序如下：
#include <stdio.h>int main()
{// 使用 char 类型（通常是 8 位）char a = 17; // 二进制表示为 0001 0001char b = -12; // -12 的补码表示为 1111 0100// 按位与操作 &// 计算规则：【有 0 为 0，全 1 为 1】// 0001 0001 -> 17// &// 1111 0100 -> -12// 0001 0000 -> 16printf("a & b = %d\n", a & b); // 输出为 16// 按位或操作 |// 计算规则：【有 1 为 1，全 0 为 0】// 0001 0001 -> 17// |// 1111 0100 -> -12// 1111 0101 -> -11printf("a | b = %d\n", a | b); // 输出为 -11// 按位异或操作 ^// 计算规则：【相同为 0，不同为 1】// 0001 0001 -> 17// ^// 1111 0100 -> -12// 1110 0101 -> -27printf("a ^ b = %d\n", a ^ b); // 输出为 -27return 0;
}程序计算过程分析：
程序在 VS Code 中的运行结果如下所示：
1.4 按位取反 ~
- 计算规则：对一个数的二进制表示中的每一位（包括符号位）进行取反操作，即将所有的 0 变为 1，所有的 1 变为 0。
- 示例：例如，对于 char 类型（8 位）整数 17
- 其二进制表示为 0001 0001
- 按位取反后变为 1110 1110
- 结果为 -18
#include <stdio.h>int main()
{// 使用 char 类型（通常是 8 位）char a = 17; // 二进制表示为 0001 0001char b = -12; // -12 的补码表示为 1111 0100// 按位取反操作 ~a// 0001 0001 -> 17// ~// 1110 1110 -> -18printf("~a = %d\n", ~a); // 输出为 -18// 按位非操作 ~b// 1111 0100 -> -12// ~// 0000 1011 -> 11printf("~b = %d\n", ~b); // 输出为 11return 0;
}程序计算过程分析：
程序在 VS Code 中的运行结果如下所示：
1.5 按位左移 <<
-
功能：将一个数的二进制表示向左移动指定的位数。左移时，左侧边缘超出的位将被丢弃，而在右侧边缘新增的位将用 0 填充。
-
语法：a << b
- a 是要被左移的数。
- b 是指定左移的位数。
-
计算规则：
- 移动操作：将 a 的二进制表示（补码）向左移动 b 位。
- 填充规则：
- 左侧边缘超出的位将被丢弃。
- 在右侧边缘新增的位用 0 填充。
-
注意事项：
- 未定义行为：如果指定左移的位数 b 是负数，则行为是未定义的（Undefined Behavior, UB）。
- 整数溢出：左移后的值可能超出该整数类型的表示范围，导致整数溢出。
- 数学应用：左移操作通常用于将数乘以 2 的幂次方（假设没有溢出）。
- 无符号整数：对于无符号整数，左移后的结果将保持为无符号数。
- 有符号整数：对于有符号整数，左移可能导致符号位的变化，进而影响整数的正负。例如，一个正数左移后符号位变为 1，那么结果将是一个负数。
-
示例：5 << 1
- 5 的八位二进制表示为：0000 0101
- 左移 1 位后为 0000 1010，即十进制数 10
- 左移 1 位相当于乘以 2 的 1 次方，即 5 * 2^1 = 10
#include <stdio.h>int main()
{// 演示未定义行为int a = 17;int undefined_shift = -1;int result = a << undefined_shift;printf("负数移位是未定义行为,示例: %d << %d = %d \n", a, undefined_shift, result); // 输出可能是任意值// 演示数学应用int b = 5;// 左移操作通常用于将数乘以 2 的幂次方（假设没有溢出）printf("%d << 4 = %d (5 * 2^4 = 80)\n", b, b << 4); // 输出为 80// 演示无符号整数unsigned int e = 17;printf("无符号整数示例: %u << 2 = %u\n", e, e << 2); // 输出为 68// 演示有符号整数int f = -12;printf("有符号整数示例: %d << 2 = %d\n", f, f << 2); // 输出为 -48return 0;
}程序计算过程分析：
程序在 VS Code 中的运行结果如下所示：
1.6 按位右移 >>
- 功能：将一个数的二进制表示向右移动指定的位数。右移时，右侧边缘超出的位将被丢弃，而左侧边缘新增的位根据整数的类型（有符号还是无符号）有不同的填充规则。
- 语法：a >> b
- a 是要被右移的数。
- b 是指定右移的位数。
- 计算规则：
- 移动操作：将 a 的二进制表示（补码）向右移动 b 位。
- 填充规则：
- 右侧边缘超出的位将被丢弃。
- 无符号整数：表现为逻辑右移，即左侧用 0 填充。
- 有符号整数：在左侧边缘新增的位的填充规则依赖于编译器的实现，通常是算术右移，即用符号位填充，但这不是标准强制要求的。
- 算术右移 (Arithmetic Right Shift)：
- 功能：在右移时，左侧空出的位用符号位填充。
- 效果：保持数值的符号不变。
- 适用：用于有符号整数类型（如 int、char 等）。
- 示例：-10 >> 1
- -10 的二进制表示为 1111 0110（假设 8 位系统）
- 算术右移 1 位后为 1111 1011，即 -5
- 逻辑右移 (Logical Right Shift)：
- 功能：在右移时，左侧空出的位用 0 填充。
- 效果：不保持数值的符号，适用于无符号数。
- 适用：用于无符号整数类型（如 unsigned int、unsigned char 等）。
- 示例：10 >> 1
- 10 的二进制表示为 0000 1010
- 逻辑右移 1 位后为 0000 0101，即 5
- 注意事项：
- 未定义行为：如果指定右移的位数 b 是负数，则行为是未定义的（Undefined Behavior, UB）。
- 数学应用：对于无符号整数，右移操作通常用于将数除以 2 的幂次方（结果总是向下取整）。
- 实现依赖：对于有符号整数，C 标准没有规定必须使用算术右移还是逻辑右移，这取决于编译器的具体实现。
#include <stdio.h>int main()
{// 演示未定义行为int a = 256;int undefined_shift = -2;int result = a >> undefined_shift;printf("负数移位是未定义行为,示例: %d >> %d = %d \n", a, undefined_shift, result); // 输出可能是任意值// 演示无符号整数的逻辑右移unsigned int b = 17;printf("无符号整数示例: %u >> 3 = %u\n", b, b >> 3); // 输出为 2// 演示有符号整数的算术右移int c = -12;printf("有符号整数示例: %d >> 3 = %d\n", c, c >> 3); // 输出为 -2// 演示算术右移和逻辑右移的区别unsigned int d = 128;printf("无符号整数（逻辑右移）示例: %u >> 1 = %u\n", d, d >> 1); // 输出为 64int e = -128;printf("有符号整数（算术右移）示例: %d >> 1 = %d\n", e, e >> 1); // 输出为 -64// 演示数学应用// 对于无符号整数，右移操作通常用于将数除以 2 的幂次方（结果总是向下取整）int f = 85;printf("%d >> 3 = %d (85 / 2^3 = 10)\n", f, f >> 3); // 输出为 10 (85/8 = 10.625，向下取整为 10)// 对于有符号整数，右移操作的行为依赖于编译器的实现// 需看编译器使用算术右移还是逻辑右移int g = -80;printf("%d >> 3 = %d (-80 / 2^3 = -10)\n", g, g >> 3); // 输出为 -10 (-80/8 = -10)return 0;
}程序计算过程分析：
程序在 VS Code 中的运行结果如下所示：
1.7 位运算符的意义与应用
在 C 语言中，位运算符（包括按位与 &、按位或 |、按位异或 ^、按位非 ~、左移 << 和右移 >>）提供了对整数类型底层二进制位的直接操作能力。这类操作在系统级或嵌入式编程中尤为重要，特别是在需要精确控制硬件寄存器、标志位或其他底层资源的场景中。
位运算的核心应用之一是对特定比特位的置位（设为 1）和复位（设为 0），而不会影响其他位的状态。例如：
- 将第 n 位置为 1：使用按位或操作结合掩码 (1 << n)，即执行 x |= (1 << n);
-
(1 << n)：
-
这是创建一个掩码（mask），它的作用是生成一个只有第 n 位为 1，其余都为 0 的数。例如：
-
1 << 0 → 0b00000001 （第 0 位为 1）
-
1 << 1 → 0b00000010 （第 1 位为 1）
-
1 << 3 → 0b00001000 （第 3 位为 1）
-
-
注意：通常从右往左数位，最低位是第 0 位。
-
-
x | (1 << n)：
-
用原来的值 x 和这个掩码做按位或操作。
-
因为 OR 的规则是：只要有 1 就为 1。
-
所以无论原来第 n 位是 0 还是 1，经过 OR 后都会变成 1。
-
-
- 将第 n 位置为 0：使用按位与操作结合取反后的掩码 ~(1 << n)，即执行 x &= ~(1 << n);
-
(1 << n)：
-
同上，先生成一个只有第 n 位为 1 的掩码。
-
-
~(1 << n)：
-
对这个掩码取反。原来是 0b00001000，取反后变成 0b11110111。
-
这样我们就得到了一个除了第 n 位是 0，其他都是 1 的掩码。
-
-
x & ~(1 << n)：
-
将 x 和这个新掩码进行按位与操作。
-
AND 的规则是：只要有一个是 0，结果就是 0。
-
所以：
-
第 n 位一定是 0（因为它和掩码中的 0 做 AND）
-
其他位保持原样（因为掩码中是 1，所以保留原来的值）
-
-
-
这些操作允许程序员高效地修改寄存器中的某些位，从而实现对硬件状态（如高低电平控制）的精细管理。由于位运算直接作用于数据的二进制表示，它们通常具有较高的执行效率，适合对性能敏感或资源受限的环境。
2 赋值运算符
在 C 语言中，赋值运算符用于将一个值赋予变量或表达式，它们是编程中非常基础且重要的操作。以下是 C 语言中常见的赋值运算符及其用法。
| 运算符 | 描述 | 操作数个数 | 表达式的值 | 副作用 |
|---|---|---|---|---|
| = | 赋值 | 2 | 左边操作数的值（赋值后的值） | 有，左边操作数的值被更新 |
| += | 相加赋值 | 2 | 左边操作数的值（相加后的值） | 有，左边操作数的值被更新 |
| -= | 相减赋值 | 2 | 左边操作数的值（相减后的值） | 有，左边操作数的值被更新 |
| *= | 相乘赋值 | 2 | 左边操作数的值（相乘后的值） | 有，左边操作数的值被更新 |
| /= | 相除赋值 | 2 | 左边操作数的值（相除后的值） | 有，左边操作数的值被更新 |
| %= | 取余赋值 | 2 | 左边操作数的值（取余后的值） | 有，左边操作数的值被更新 |
| <<= | 左移赋值 | 2 | 左边操作数的值（左移后的值） | 有，左边操作数的值被更新 |
| >>= | 右移赋值 | 2 | 左边操作数的值（右移后的值） | 有，左边操作数的值被更新 |
| &= | 按位与赋值 | 2 | 左边操作数的值（按位与后的值） | 有，左边操作数的值被更新 |
| ^= | 按位异或赋值 | 2 | 左边操作数的值（按位异或后的值） | 有，左边操作数的值被更新 |
| |= | 按位或赋值 | 2 | 左边操作数的值（按位或后的值） | 有，左边操作数的值被更新 |
2.1 左值和右值
- 左值（Lvalue）：左值是一个具有确定内存位置的变量或表达式，可以出现在赋值操作的左侧。例如：变量名、数组元素、结构体成员等。
- 右值（Rvalue）：右值是一个表示值的表达式，但没有明确的内存位置。右值通常是一个常量、算术表达式的结果、函数调用返回的结果等。
2.2 注意事项
- 赋值运算符的第一个操作数（左值）必须是变量的形式，第二个操作数可以是任何形式的表达式。
- 左值必须可修改：赋值操作要求左侧必须是一个左值，即一个可以存储新值的内存位置。
- 右值提供值：赋值操作的右侧可以是一个右值，它提供了要赋给左值的具体值。
-
示例：
- 正确用法：a = b + 25;（a 是左值，b + 25 是右值）
- 错误用法：b + 25 = a;（尝试将右值 b + 25 用作左值，这是不允许的）
- 编译错误结果，如下图所示：
2.3 复合赋值运算符的使用
复合赋值运算符（如 +=、-= 等）的用法是将等号右边的表达式首先计算为一个整体的值，然后将这个值与等号左边的变量进行相应的运算，并将结果赋值回该变量。
a += b + 2;
等价于
a = a + (b + 2);2.4 案例演示
#include <stdio.h>int main()
{int a = 10, b = 20, c = 30, d = 4;// 简单的赋值a = 5;printf("a = %d\n", a); // a = 5// 加法赋值c += 3; // c = c + 3 = 30 + 3printf("c = %d\n", c); // c = 33// 减法赋值c -= b; // c = c - b = 33 - 20printf("c = %d\n", c); // c = 13// 乘法赋值a *= 2; // a = a * 2 = 5 * 2printf("a = %d\n", a); // a = 10// 除法赋值b /= 2; // b = b / 2 = 20 / 2printf("b = %d\n", b); // b = 10// 取模赋值c %= 3; // c = c % 3 = 13 % 3printf("c = %d\n", c); // c = 1// 连等写法int e = 12, f;f = e *= a; // f = e * a = 12 * 10// 先计算 e *= a，然后将结果赋值给 fprintf("e = %d\n", e); // e = 120printf("f = %d\n", f); // f = 120// 左移赋值d <<= 2; // d = d << 2 = 4 << 2printf("d = %d\n", d); // d = 16// 右移赋值d >>= 1; // d = d >> 1 = 16 >> 1printf("d = %d\n", d); // d = 8// 按位与赋值a &= 1; // a = a & 1 = 10 & 1printf("a = %d\n", a); // a = 0// 按位异或赋值b ^= 3; // b = b ^ 3 = 10 ^ 3printf("b = %d\n", b); // b = 9// 按位或赋值b |= 4; // b = b | 4 = 9 | 4printf("b = %d\n", b); // b = 13return 0;
}程序在 VS Code 中的运行结果如下所示：
2.5 复合赋值运算符表达式的值
在 C 语言中，复合赋值运算符（如 +=、-=、*= 等）不仅简化了赋值操作，还具有特定的表达式值。复合赋值运算符组成的表达式，其值为赋值后的左边操作数的值。以下通过一个案例来演示这一特性：
#include <stdio.h>int main()
{int n = 5;// 使用复合赋值运算符 +=，并打印表达式的结果printf("n += 3 的结果是: %d\n", n += 3);// 执行过程：// 1. 计算 n + 3 = 8// 2. 将 8 赋给 n// 3. 表达式 n += 3 的值为赋值后的 n 的值，即 8// 输出：n += 3 的结果是: 8// 验证 n 的值printf("此时 n 的值是: %d\n", n); // 输出：此时 n 的值是: 8return 0;
}- 初始时，n 的值为 5。
- 执行 n += 3 时，先计算 n + 3 的值（即 8），然后将该值赋给 n。
- 表达式 n += 3 的值为赋值后的 n 的值，即 8，因此 printf 函数会输出 8。
- 最后，再次打印 n 的值，确认 n 已经被更新为 8。
程序在 VS Code 中的运行结果如下所示：
2.6 连等写法
C 语言支持连等写法，即在一个表达式中连续进行多个赋值操作。连等写法的赋值顺序是从右向左进行的。以下通过一个案例来演示连等写法：
#include <stdio.h>int main()
{int x, y;// 使用连等写法 x = y = 99x = y = 99;// 执行过程解析：// 1. y = 99; 先执行，将 y 赋值为 99// 2. 然后 x = y; 执行，将 x 赋值为 y 的值，即 99// 打印 x 和 y 的值printf("x = %d, y = %d\n", x, y); // 输出：x = 99, y = 99return 0;
}- 在 x = y = 99; 这个连等写法中，赋值操作是从右向左进行的。
- 首先，99 被赋给 y，此时 y 的值为 99。
- 然后，y 的值（即 99）被赋给 x，此时 x 的值也为 99。
- 最终，printf 函数输出 x = 99, y = 99，验证了连等写法的执行顺序和赋值过程。
程序在 VS Code 中的运行结果如下所示：
3 三元运算符
3.1 基本语法
三元运算符（也称为条件运算符）的基本语法如下：
条件表达式 ? 表达式1 : 表达式2;- 条件表达式：一个逻辑表达式，用于判断其真假。
- 表达式1：如果条件表达式为真（非 0），则整个三元运算符的值为表达式 1 的值。
- 表达式2：如果条件表达式为假（0），则整个三元运算符的值为表达式 2 的值。
3.2 案例演示
#include <stdio.h>int main()
{int a = 99;int b = 99;// 使用三元运算符来决定 res 的值int res = a > b ? a++ : b--;// 因为 a 不大于 b，所以执行 b--，并将结果赋值给 res// 注意：b-- 是后缀自减，意味着先返回 b 的当前值（99），然后再将 b 减 1// res 被赋值为 99，然后 b 变为 98printf("a=%d\n", a); // 输出 a=99，因为 a 没有被改变printf("b=%d\n", b); // 输出 b=98，因为 b 在前面的条件运算符中自减了printf("res=%d\n", res); // 输出 res=99，因为 res 被赋值为 b 自减之前的值float n1 = a > b ? 1.1 : 1.2; // 条件表达式为真，整个表达式的值是表达式1：1.1// 注意：由于 b 在前面的条件运算符中已经被自减，所以这里 b 的值是 98printf("n1=%.2f\n", n1); // 输出 n1=1.10return 0;
}程序在 VS Code 中的运行结果如下所示：
3.3 案例：计算两个数的最大值
#include <stdio.h>int main()
{int a = 10;int b = 100;// 使用三元运算符计算 a 和 b 中的最大值int max = a > b ? a : b;printf("a 和 b 中最大的数字：%d", max); // 输出：a 和 b 中最大的数字：100return 0;
}程序在 VS Code 中的运行结果如下所示：
3.4 案例：计算三个数的最大值
#include <stdio.h>int main()
{int a = 10;int b = 100;int c = 199;// 1. 使用两次三元运算符来计算 a、b 和 c 中的最大值int max_a_b = a > b ? a : b;int max_a_b_c = max_a_b > c ? max_a_b : c;// 输出 a、b 和 c 中最大的数字printf("a、b、c 中最大的数字：%d\n", max_a_b_c); // 输出：a、b、c 中最大的数字：199// 2. 使用嵌套的三元运算符来找出 a、b、c 中的最大值// 首先比较 a 和 b，然后将较大的值与 c 比较int max = (a > b ? a : b) > c ? (a > b ? a : b) : c;// 输出 a、b 和 c 中最大的数字printf("a、b、c 中最大的数字：%d\n", max); // 输出：a、b、c 中最大的数字：199// 3. 也可以简化为下面的写法：max = (a > b ? (a > c ? a : c) : (b > c ? b : c));// 输出 a、b 和 c 中最大的数字printf("a、b、c 中最大的数字：%d\n", max); // 输出：a、b、c 中最大的数字：199// 4. 也可以使用 if-else 语句来找出 a、b、c 中的最大值// 后续在学习 if-else 语句时会详细讲解return 0;
}程序在 VS Code 中的运行结果如下所示：
4 逗号运算符
4.1 基本语法
逗号运算符（,）是 C 语言中一个简单但强大的运算符，用于将多个表达式连接在一起。它的基本语法如下：
表达式1, 表达式2, 表达式3, ..., 表达式N;- 表达式1, 表达式2, ..., 表达式N：这些是逗号运算符连接的多个表达式。
4.2 表达式的值
逗号运算符的特性如下：
- 求值顺序：逗号运算符从左到右依次计算每个表达式的值。
- 表达式的值：整个逗号表达式的值为最后一个表达式的值。
4.3 案例演示
#include <stdio.h>int main()
{int a = 5, b = 10, c = 15;// 使用逗号运算符依次执行多个表达式int result = (a = b, b = c, c = a + b);// 执行过程解析：// 1. a = b，将 b 的值赋给 a，此时 a = 10, b = 10, c = 15// 2. b = c，将 c 的值赋给 b，此时 a = 10, b = 15, c = 15// 3. c = a + b，将 a 和 b 的和赋给 c，此时 a = 10, b = 15, c = 25// 最后，result 被赋值为 c 的值，即 25// 打印结果printf("a = %d, b = %d, c = %d\n", a, b, c); // 输出：a = 10, b = 15, c = 25printf("result = %d\n", result); // 输出：result = 25return 0;
}程序在 VS Code 中的运行结果如下所示：
4.4 使用场景
逗号运算符通常用于以下场景：
- 简化代码：在需要执行多个操作但不想使用多行代码时，可以使用逗号运算符。
- 循环和条件语句：在 for 循环的初始化或更新部分，或者在需要多个条件判断的地方，可以使用逗号运算符。
4.5 注意事项
- 可读性：虽然逗号运算符可以简化代码，但过度使用可能会降低代码的可读性。
- 优先级：逗号运算符的优先级较低，因此在复杂的表达式中，建议使用括号来明确运算顺序。
5 运算符优先级
5.1 运算符优先级表格说明
| 优先级 | 运算符 | 名称或含义 | 结合方向 |
|---|---|---|---|
| 1 | [] | 数组下标 | 左到右 |
| () | 函数调用、圆括号 | ||
| . | 成员选择（对象） | ||
| -> | 成员选择（指针） | ||
| 2 | -（单目） | 负号运算符 | 右到左 |
| (类型) | 强制类型转换 | ||
| ++ | 自增运算符 | ||
| -- | 自减运算符 | ||
| *（单目） | 取值运算符（解引用） | ||
| &（单目） | 取地址运算符 | ||
| ! | 逻辑非运算符 | ||
| ~ | 按位取反运算符 | ||
| sizeof | 长度运算符 | ||
| 3 | / | 除 | 左到右 |
| *（双目） | 乘 | ||
| % | 余数（取模） | ||
| 4 | + | 加 | 左到右 |
| -（双目） | 减 | ||
| 5 | << | 左移 | 左到右 |
| >> | 右移 | ||
| 6 | > | 大于 | 左到右 |
| >= | 大于等于 | ||
| < | 小于 | ||
| <= | 小于等于 | ||
| 7 | == | 等于 | 左到右 |
| != | 不等于 | ||
| 8 | & | 按位与 | 左到右 |
| 9 | ^ | 按位异或 | 左到右 |
| 10 | | | 按位或 | 左到右 |
| 11 | && | 逻辑与 | 左到右 |
| 12 | || | 逻辑或 | 左到右 |
| 13 | ?: | 条件运算符 | 右到左 |
| 14 | = | 赋值运算符 | 右到左 |
| /= | 除后赋值 | ||
| *= | 乘后赋值 | ||
| %= | 取模后赋值 | ||
| += | 加后赋值 | ||
| -= | 减后赋值 | ||
| <<= | 左移后赋值 | ||
| >>= | 右移后赋值 | ||
| &= | 按位与后赋值 | ||
| ^= | 按位异或后赋值 | ||
| |= | 按位或后赋 | ||
| 15 | , | 逗号运算符 | 左到右 |
- 优先级记忆：虽然运算符优先级表看起来复杂，但通常不需要刻意记忆所有优先级。一般来说，一元运算符（如 !、-（单目）、++、-- 等）的优先级高于算术运算符，算术运算符的优先级高于关系运算符，关系运算符的优先级高于逻辑运算符，逻辑运算符的优先级高于三元运算符，三元运算符的优先级高于赋值运算符。
- 常用优先级关系：自增自减 > 逻辑非 ! > 算术运算符 > 关系运算符 > 逻辑与 && > 逻辑或 || > 条件运算符 ?: > 赋值运算符。
- 使用括号：如果对运算符的优先级不确定，或者为了代码的可读性，可以直接使用括号来明确运算顺序。括号可以覆盖任何运算符的优先级，确保表达式按照预期的方式计算。
5.2 复杂表达式的计算分析
表达式 5 > 3 && 8 < 4 - !0 的计算过程分析
问题：对于表达式 5 > 3 && 8 < 4 - !0 的最终值是多少？计算过程是怎样的？
计算过程：
- 短路性质：首先计算 && 左边的表达式 5 > 3，其逻辑值为 1。
- 右边表达式：计算 && 右边的表达式 8 < 4 - !0。
- 非运算：!0 的逻辑值为 1。
- 算术运算：4 - 1 的结果为 3。
- 关系运算：8 < 3 的逻辑值为 0。
- 逻辑与运算：整个表达式的值为 1 && 0，最终逻辑值为 0。
表达式 a + b < c && b == c && a || b + c && b + c 的计算过程分析
问题：若 a = 2，b = 3，c = 4，表达式 a + b < c && b == c && a || b + c && b + c 的计算过程是怎样的？值为多少？
计算过程：
- 短路性质：首先计算 a + b < c，即 2 + 3 < 4，其逻辑值为 0。
- 短路效果：b == c && a 不会执行，|| 左边的值为 0。
- 右边表达式：计算 b + c && b + c。
- 算术运算：b + c 的结果为 7。
- 逻辑与运算：7 && 7 的逻辑值为 1。
- 逻辑或运算：0 || 1 的逻辑值为 1。
表达式 (m = a > b) && (n = c > d) 的计算过程分析
问题：设有 int a = 1, b = 2, c = 3, d = 4, m = 2, n = 2；执行 (m = a > b) && (n = c > d) 后 m 和 n 的值分别是多少？表达式的结果是多少？
计算过程：
- 短路性质：首先计算(m = a > b)。
- 关系比较：a > b，即 1 > 2，其逻辑值为 0。
- 赋值运算：m = 0。
- 短路效果：(n = c > d) 不执行。
- 最终结果：
- m 的值为 0。
- n 的值为 2。
- 整个表达式的结果为 0。
总结与建议：
- 避免复杂表达式：尽量简化表达式。
- 明确执行顺序：使用小括号明确执行顺序，避免依赖运算符优先级。
- 拆分表达式：复杂表达式拆分为多个步骤，提高可读性和可维护性。
6 编程练习
6.1 会员折扣
某商店对会员提供折扣：
- 消费满 100 元，打 9 折
- 消费满 200 元，打 8 折
- 否则，无折扣
编写一个程序，根据消费金额计算最终价格。
#include <stdio.h>int main()
{float amount; // 消费金额printf("请输入消费金额：");scanf("%f", &amount); // 输入消费金额float final_amount = (amount >= 200) ? amount * 0.8 : (amount >= 100) ? amount * 0.9: amount;printf("最终价格：%.2f 元\n", final_amount);return 0;
}程序在 VS Code 中的运行结果如下所示：
6.2 多任务处理
假设你在管理一个任务列表，每个任务有 ID、优先级和状态。编写一个程序，更新任务的状态和优先级，并输出更新后的信息。
#include <stdio.h>int main()
{int task_id = 101, priority = 3, status = 0;// 更新任务优先级和状态int updated = (priority = 5, status = 1);printf("任务 ID：%d，优先级：%d，状态：%d\n", task_id, priority, status);return 0;
}程序在 VS Code 中的运行结果如下所示：
6.3 灯的开关状态
你有一个 8 位的整数表示 8 个灯的状态（1 表示开，0 表示关）。初始状态为所有灯关闭。编写一个程序，打开第 2 和第 7 个灯，并关闭第 4 个灯（如果它是开的）。
#include <stdio.h>int main()
{unsigned char lights = 0b00000000; // 所有灯关// 打开第 2 和第 7 个灯lights |= (1 << 1) | (1 << 6);// 关闭第 4 个灯（如果它是开的）lights &= ~(1 << 3);return 0;
}6.4 权限检查
在一个系统中，权限使用一个整数的二进制位表示。例如，0000 1010 表示用户有权限 2 和 4（从右到左，最低位为权限 1）。编写一个程序，给用户添加权限 3，并检查用户是否有权限 4。
#include <stdio.h>int main()
{unsigned char permissions = 0b00001000; // 初始权限// 添加权限 3permissions |= (1 << 2);// 检查是否有权限 4int has_permission_4 = (permissions & (1 << 3)) != 0;// 解释上面这行代码// (permissions & (1 << 3)) != 0// permissions & (1 << 3) 是将 permissions 的第 3 位与 1 进行按位与操作，如果第 3 位为 1，则结果为 1，否则为 0。// != 0 是判断结果是否不等于 0，如果不等于 0，则表示第 3 位为 1，即有权限 4，否则没有权限 4。// 加上 != 0 使得代码更加规范，因为 (permissions & (1 << 3)) 的结果是一个整数，而不是一个布尔值。printf("用户是否有权限 4？%s\n", has_permission_4 ? "有" : "无");return 0;
}程序在 VS Code 中的运行结果如下所示：
6.5 温度更新
假设你有一个初始温度值为 25 摄氏度。由于天气变化，温度变化如下：
- 上午升温 3 度。
- 下午降温 2 度。
- 晚上升温 1 度。
编写一个程序，计算晚上的最终温度。
#include <stdio.h>int main()
{float temperature = 25;temperature += 3; // 上午升温temperature -= 2; // 下午降温temperature += 1; // 晚上升温printf("晚上的最终温度：%.2f 摄氏度\n", temperature);return 0;
}程序在 VS Code 中的运行结果如下所示：
