3、运算符与表达式：从语法规则到求值本质

运算符是C++语言中构建表达式的核心构件，它们决定了数据如何被加工、比较与组合。本章将系统梳理C++中的七大类运算符——算术、关系、逻辑、位、赋值、三目及逗号运算符，并深入剖析运算符优先级与结合性对表达式求值顺序的影响。理解这些内容不仅是编写正确代码的前提，更是后续学习函数重载、模板元编程和性能优化的基石。我们将从每个运算符的底层语义出发，结合典型代码案例与常见陷阱，帮助你建立对C++表达式求值机制的完整认知。

上图展示了C++运算符体系的整体框架。表达式由操作数和运算符组合而成，而运算符的优先级决定了表达式中各子表达式的结合顺序，结合性则决定了同优先级运算符的求值方向。理解这张图的关键在于：优先级解决“谁先算”的问题，结合性解决“同级别谁先算”的问题，而最终求值还受到类型转换和副作用（如自增自减）的影响。下面我们逐一深入每个运算符类别。

3.1 算术运算符：基础运算与隐式类型转换

核心原理

算术运算符包括二元运算符 +、-、*、/、% 和一元运算符 +、-、++、--。其核心语义遵循数学规则，但在C++中需特别注意两点：整数除法截断和取模运算的符号。例如 7/2 结果为 3（截断小数），而 -7%2 在C++11标准中结果为 -1（符号与被除数一致）。

隐式类型转换规则

当操作数类型不同时，编译器会执行算术转换：首先进行整型提升（如 char、short 提升为 int），然后按“低精度向高精度转换”的规则统一类型。具体顺序为：bool → char → short → int → unsigned int → long → unsigned long → long long → float → double → long double。这一规则可能导致精度损失，例如 int 与 float 运算时，int 会转换为 float。

// 案例：混合类型算术运算
int a = 5;
double b = 2.5;
auto result = a + b;  // result 类型为 double，值为 7.5
int c = 7;
int d = 2;
int q = c / d;        // q = 3，整数除法截断
int r = c % d;        // r = 1，取余

常见误区

• 溢出问题：int 最大值加1会回绕为负数，这是未定义行为（UB），应使用 long long 或检查边界。
• 自增自减的副作用：i++ 返回旧值，++i 返回新值。在同一个表达式中多次使用自增操作符（如 i++ + i++）是未定义行为，应避免。
• 除以零：整数除以零会导致程序崩溃，浮点数除以零则得到 inf 或 nan。

3.2 关系运算符与逻辑运算符：条件判断的基石

核心原理

关系运算符（<、>、<=、>=、==、!=）返回 bool 类型。逻辑运算符（&&、||、!）操作 bool 值，并具有短路求值特性：a && b 中若 a 为 false，则 b 不会被求值；a || b 中若 a 为 true，则 b 不会被求值。这一特性常用于指针判空后再解引用。

判断方法

1. 先计算关系表达式，得到 bool 结果。
2. 再应用逻辑运算符，注意短路规则。
3. 最后将结果用于 if、while 等控制结构。

// 案例：短路求值保护
int* ptr = nullptr;
if (ptr != nullptr && *ptr > 10) {
    // 安全：ptr 为 nullptr 时，不会执行 *ptr
}
// 错误示范：if (*ptr > 10 && ptr != nullptr)  // 先解引用空指针，崩溃！

常见误区

• 误用赋值代替比较：if (x = 5) 是赋值，永远为真。应写 if (x == 5)。
• 浮点数相等比较：直接使用 == 比较浮点数可能因精度误差失败，应使用 fabs(a-b) < 1e-9。
• 逻辑运算符优先级：! 优先级高于 &&，&& 高于 ||。建议用括号明确意图。

3.3 位运算符：底层操作的利器

核心原理

位运算符直接操作整型数据的二进制位，包括：&（按位与）、|（按位或）、^（按位异或）、~（按位取反）、<<（左移）、>>（右移）。位运算常用于掩码操作、标志位管理、高效乘除（左移1位等于乘2，右移1位等于除2）。

操作流程

1. 确定操作数的二进制表示（注意补码形式）。
2. 按位执行逻辑运算。
3. 左移右移时，注意无符号数与有符号数的区别：有符号数右移是算术移位（符号位填充），无符号数是逻辑移位（补0）。

// 案例：使用位掩码管理权限
const int READ = 1 << 0;   // 0001
const int WRITE = 1 << 1;  // 0010
const int EXEC = 1 << 2;   // 0100
int perm = READ | WRITE;    // 0011
if (perm & READ) { /* 有读权限 */ }
perm &= ~WRITE;             // 清除写权限

常见误区

• 有符号数右移：负数右移是算术移位，结果可能不是预期值。
• 移位位数超过类型宽度：如 int a = 1; a << 32; 是未定义行为。
• 混淆逻辑与位运算：&& 与 & 完全不同，前者短路且返回 bool，后者按位操作。

3.4 赋值运算符与三目运算符：简洁与风险并存

核心原理

赋值运算符 = 及其复合形式（+=、-=、*=、/=、%=、<<=、>>=、&=、^=、|=）将右侧表达式的值赋给左侧左值。赋值表达式本身也有值（即被赋的值），因此可以链式赋值：a = b = c = 0;。三目运算符 cond ? expr1 : expr2 根据条件选择两个表达式之一，其类型为两个表达式的公共类型。

判断方法

• 赋值运算符右结合，从右向左执行。
• 三目运算符优先级仅高于赋值和逗号，低于其他运算符。
• 三目运算符的两个分支中只有一个会被求值，不会短路但会跳过未选分支。

// 案例：三目运算符的类型推导
int x = 10;
double y = 3.14;
auto z = (x > 5) ? x : y;  // z 类型为 double，因为 int 和 double 的公共类型是 double
// 链式赋值
int a, b, c;
a = b = c = 5;  // 从右向左：c=5, b=5, a=5

常见误区

• 三目运算符类型不一致：true ? 1 : 2.5 结果为 double 类型，值为 1.0，可能造成精度损失。
• 赋值与比较混淆：在条件中误用 = 而非 ==。
• 复合赋值与普通赋值的区别：a += b 等价于 a = a + b，但 a 只被求值一次，对于复杂表达式（如 arr[i++] += 5）行为不同。

3.5 运算符优先级与结合性：表达式求值的核心规则

核心原理

C++定义了完整的运算符优先级表（从高到低）：:: → 后缀 ++/-- → 一元运算符 → 乘除 → 加减 → 移位 → 关系 → 相等性 → 位与 → 位异或 → 位或 → 逻辑与 → 逻辑或 → 三目 → 赋值 → 逗号。结合性决定了同优先级运算符的求值方向：大多数二元运算符左结合（从左到右），赋值、三目和一元运算符右结合。

判断方法

1. 先找优先级最高的运算符，将其操作数分组。
2. 对同优先级运算符，按结合性方向分组。
3. 注意括号可以改变默认优先级。

// 案例：复杂表达式解析
int a = 2, b = 3, c = 4;
int result = a + b * c - (a + b) / c;
// 解析步骤：
// 1. 括号内 a+b = 5
// 2. b*c = 12
// 3. 5/c = 1（整数除法）
// 4. a + 12 - 1 = 13

常见误区

• 过度依赖优先级：可读性差，建议用括号明确意图。
• 未定义行为：如 i++ + i++ 中，i 的修改次数超过一次，行为未定义。
• 函数参数求值顺序：C++17之前，函数参数的求值顺序未指定，f(i++, i++) 是未定义行为。

3.6 表达式求值的完整案例：从代码到结果

场景描述

假设我们需要实现一个简单的位图图像处理函数，计算像素点的灰度值。输入为RGB三个通道的8位无符号整数，输出为灰度值（0-255）。我们使用加权平均法：gray = 0.299*R + 0.587*G + 0.114*B。但为了性能，我们改用整数运算和移位实现。

初始代码与问题

// 初始版本：浮点运算
unsigned char rgb2gray_float(unsigned char R, unsigned char G, unsigned char B) {
    return static_cast<unsigned char>(0.299f * R + 0.587f * G + 0.114f * B);
}
// 问题：浮点运算慢，且存在精度误差

优化方案

// 优化版本：整数运算 + 移位
unsigned char rgb2gray_int(unsigned char R, unsigned char G, unsigned char B) {
    // 使用 16 位精度：0.299 ≈ 19595/65536, 0.587 ≈ 38470/65536, 0.114 ≈ 7471/65536
    unsigned int gray = (19595 * R + 38470 * G + 7471 * B) >> 16;
    return static_cast<unsigned char>(gray);
}

分析过程

1. 将浮点系数转换为16位定点数：0.299 * 65536 = 19595.264 ≈ 19595。
2. 计算加权和：19595*R + 38470*G + 7471*B，结果最大为 19595*255 + 38470*255 + 7471*255 = 255*65536 = 16711680，在 unsigned int 范围内。
3. 右移16位相当于除以65536，得到0-255的灰度值。

结果对比

整数版本性能提升4倍，且误差在可接受范围内。这个案例展示了运算符优先级（乘法高于加法）、移位运算和类型转换的综合应用。

3.7 常见误区与总结复盘

误区清单

• 优先级记忆混乱：建议记住口诀“单算移关与，异或逻条赋”（一元→算术→移位→关系→位与→异或→位或→逻辑与→逻辑或→条件→赋值）。
• 短路求值误用：在 a || b 中，如果 a 为真，b 不会执行，若 b 有副作用（如函数调用），可能产生意外结果。
• 类型转换陷阱：unsigned int 与 int 混合运算时，int 会转换为 unsigned int，导致负数变成大正数。
• 自增自减的序列点问题：C++11后，同一表达式中对同一变量多次修改是未定义行为，编译器可能给出不同结果。

总结复盘

本章的核心在于理解运算符的三层语义：语法层面（优先级与结合性）、类型层面（隐式转换规则）、求值层面（副作用与序列点）。在实际编码中，建议遵循以下原则：

1. 使用括号明确优先级，不依赖记忆。
2. 避免在同一个表达式中多次修改同一变量。
3. 混合类型运算时，显式进行类型转换。
4. 利用短路求值简化条件判断，但注意副作用。
5. 位运算只用于无符号整数或明确语义的场景。

通过本章的学习，你应该能够熟练分析任何复杂表达式的求值过程，并能识别潜在的未定义行为。下一阶段，我们将把这些运算符应用于控制流和函数设计中，构建更复杂的程序逻辑。