表达式

直觉：程序里每一个“算”都有规矩

想象一条工厂流水线：原料从一端进入，经过切割、打磨、组装、喷漆——每一步都有固定的顺序，不能先喷漆再切割。每一步的操作员也只认特定规格的原料：你给切割工塞一块布，他只会摇头。

在 C++ 里，每一次「算」就是这条流水线上的一个加工步骤。你把要算的数据（原料）和要做的动作（加工）组合起来，告诉计算机按什么顺序一步步算出结果。优先级高的工序先做（就像先切割再喷漆），不同类型的料要先统一规格才能放同一条线。

没有这些规矩会怎样？a + b * c 到底先算加法还是乘法，全看计算机心情——结果乱套，bug 遍地。这一章就把流水线的运行手册讲透。

表达式——把"计算"写出来

在 C++ 里，表达式（expression） 就是你告诉计算机"算一下这个"的基本单位。一个最简单的表达式可以只是一个变量名或一个字面值（比如 42 或 x），它们本身就是一个求值结果。一旦你把运算符和操作数组合起来——比如 a + b * c——就形成了一个更复杂的表达式。

每个表达式求值之后都会产生一个结果，并且结果也有自己的类型。比如 3 + 4 的结果是 7（类型是 int），3.0 + 4.0 的结果是 7.0（类型是 double）。

表达式的核心构成只有两类东西：

• 操作数（operand）——参与运算的数据，可以是变量、字面值，也可以是另一个子表达式的结果
• 运算符（operator）——对操作数执行的操作，比如 + 做加法，* 做乘法

运算符优先级——哪个先算？

当你写出 a + b * c 这句时，计算机看到三个东西：a、b、c 和两个运算符 +、*。问题来了——先算 + 还是先算 *？答案取决于 优先级（precedence）。

C++ 里 乘除 * / % 的优先级比加减 + - 高，这和你在数学课上学到的规则一模一样。所以 a + b * c 等价于 a + (b * c)。

来用表达式树把这件事看清楚——叶子是最原始的数据，越深的层越先算：

运算符结合律——同级从左到右（或反过来）

如果一条流水线上两个工序的优先级完全一样怎么办？比如 a - b + c——减法和加法优先级相同。这时候 结合律（associativity） 上场：加减是左结合的，也就是从左到右算——等效于 (a - b) + c。

赋值运算符是右结合的：a = b = 0 分组为 a = (b = 0)。前缀一元运算符也按右到左分组，而后缀自增/自减属于优先级更高的 postfix expression。结合方向只决定语法分组，不应被读成运行时求值顺序。

下面是 C++ 常用运算符的优先级速查表：

算术运算符——加减乘除取余

C++ 提供了五种基本 算术运算符（arithmetic operator）：+ - * / %。前四种和数学课一样，注意两点：

• 整数除法 / 会截断小数部分：7 / 2 的结果是 3，不是 3.5。要得到小数结果，把至少一个操作数换成 double：7.0 / 2 才是 3.5。
• 取余 % 的操作数必须是整数：7 % 2 结果是 1（7 除以 2 的余数）。% 不能用于浮点数。

#include <iostream>
int main() {
    int a = 7, b = 2;
    std::cout << a + b  << std::endl;  // 9
    std::cout << a - b  << std::endl;  // 5
    std::cout << a * b  << std::endl;  // 14
    std::cout << a / b  << std::endl;  // 3（整数除法截断）
    std::cout << a % b  << std::endl;  // 1（取余数）
    std::cout << 7.0 / 2 << std::endl; // 3.5（浮点除法）
    return 0;
}

赋值运算符——不只是等号

赋值运算符（assignment operator） 最基本的形式是 =——把右边的值写进左边的变量。但它不止于此：

C++ 还有 复合赋值运算符（compound assignment）——把运算和赋值合并成一步：

int x = 10;
x += 3;   // 等价于 x = x + 3;  → x 变成 13
x -= 5;   // 等价于 x = x - 5;  → x 变成 8
x *= 2;   // 等价于 x = x * 2;  → x 变成 16
x /= 4;   // 等价于 x = x / 4;  → x 变成 4
x %= 3;   // 等价于 x = x % 3;  → x 变成 1

复合赋值的好处是：少写一次变量名（x += 1 比 x = x + 1 简洁），而且意图更清晰——"在原值基础上加"。赋值表达式本身会返回被赋值之后的值，因此你可以链式赋值：

int a, b, c;
a = b = c = 0;   // 从右往左：c=0 返回 0→b=0 返回 0→a=0。三个变量都是 0。

递增与递减——加一减一的"快车道"

++ 和 -- 是 C++ 里最常用的两个 递增递减运算符——分别让变量加 1 和减 1。它们有前缀（++i、--i）和后缀（i++、i--）两种写法，对变量最终值的影响完全一样（i 都会变成 i+1），但表达式本身的返回值不同——这是 C++ 初学者最频繁踩的坑之一。

下面这张时间线图直观对比了两种写法在"运算的瞬间"到底发生了什么：

核心口诀：前缀先加再用，后缀先用再加。

int i = 5, j = 0;
 
// ++i：先自增为 6，再赋给 j。结果 i=6, j=6。
j = ++i;
 
// i++：先把旧值 6 赋给 j，然后 i 自增为 7。结果 i=7, j=6。
j = i++;

类型转换——当不同规格的原料被放进同一条流水线

当你把两种不同类型的值放进同一个表达式时——比如 3.14 + 10，一个 double 加一个 int——C++ 怎么处理？答案是 隐式类型转换（implicit conversion）：编译器会自动把"窄类型"提升为"宽类型"，确保运算在统一的类型下进行。

3.14 + 10 中，10 这个 int 会被自动转换为 double 类型的 10.0，然后两个 double 相加得 13.14。整个过程你不需要写任何转换代码。

下面的转换链图展示了 C++ 内建类型之间的隐式转换方向：

很多时候，隐式转换的方向你可能需要反过来——比如把一个 double 变成 int。这时候你必须用 显式转换（explicit cast），最推荐的是 C++ 风格 static_cast：

double pi = 3.14159;
int rounded = static_cast<int>(pi);  // 显式转换：把 pi 截断为 3
int bad = pi;                         // 隐式截断（虽然能编译，但不推荐）
// int bad2{pi};                      // ❌ 列表初始化会拒绝窄化转换

static_cast 的好处：它明确告诉编译器也告诉读代码的人——"我知道这里会丢精度，这是我故意的"。用 static_cast 代替 C 风格转换 (int)pi，代码意图更清晰、更安全。

官方运算符族与求值契约

Chapter 4 还包括 logical/relational operators、member access、conditional、bitwise、sizeof、comma operator 和 order of evaluation。它们不能只靠优先级表带过，因为“表达式怎样分组”和“操作数何时求值”是两套规则。

求值顺序在 C++11 中常常未指定。优先级只把 a + b * c 分组为 a + (b * c)，不保证函数参数或大多数二元运算符的左操作数先算。若同一 scalar object 的修改与另一次修改/读取彼此 unsequenced，行为未定义。

&&、||、conditional ?: 与 comma operator 的选定分支具有明确定序，并可 short-circuit；bitwise &、| 不是逻辑短路。f() && g() 在 f() 为假时不会调用 g()，但 f() & g() 会计算两边。

左值与右值影响赋值、引用绑定和 member access。Assignment 左侧必须是可修改 lvalue；decltype((x)) 对 lvalue 得到引用；std::move(x) 只把表达式转换为可移动的 xvalue，不立即移动对象。

常被遗漏的运算符族可以按责任检查：

• Logical/relational：比较产生 bool，不要链写 a < b < c；第二次比较实际拿 bool 与 c 比。
• Member access：. 接对象，-> 接指针；ptr->m 等价于 (*ptr).m，括号来自 postfix/member precedence。
• Conditional：cond ? a : b 只求值一个分支，结果类型由两个分支共同决定。
• Bitwise：只用于 integral operands；位移量必须合法，signed 位运算要特别警惕表示与溢出。
• sizeof：返回 size_t，通常不求值普通 operand；对数组得到完整数组大小，对指针只得指针大小。
• Comma：先求值左侧并丢弃其值，再求值右侧；不要与函数参数之间的逗号混淆。

Widget object;
Widget* pointer = &object;
auto a = object.member;       // . 访问对象成员
auto b = pointer->member;     // 等价于 (*pointer).member
auto bytes = sizeof object;   // 对象大小
auto chosen = ready ? a : b;  // 只求值选中的分支

动手：拆解一个复杂表达式的求值过程

下面把一个嵌套赋值 + 复合运算的表达式一步步拆解，看计算机到底在每一步做了什么运算、每个变量的值怎么变化。

猜一猜：int a = 5, b = 2; int c = ++a * b-- + 3; 执行完以后 a、b、c 各是什么？通过下面 Stepper 一步步看。

代码速查：表达式常用写法

下面把你日常写代码时最常见的表达式模式汇总在一起，快速对照：

// 算术运算
int sum = a + b;
int diff = a - b;
int product = a * b;
int quotient = a / b;       // 整数除法会截断
int remainder = a % b;      // 取余，操作数必须是整数
 
// 复合赋值（比 x = x + 1 更简洁）
x += 1;   // 自增 1
x *= 2;   // 翻倍
x %= 10;  // 取模后赋回
 
// 递增递减（单独用效果一样，有赋值目标时才区分）
++i;      // 前缀：先加再用，返回值是新值
i++;      // 后缀：先用后加，返回值是旧值
 
// 类型转换
double d = 3.14159;
int i = static_cast<int>(d);   // 显式截断 → 3
auto f = static_cast<float>(d); // 显式变 float

三行"安全法则"帮你避免 90% 表达式 bug：

1. 不确定优先级就加括号——括号最早算，且让意图一目了然
2. 别在一个表达式里多次改同一个变量——拆成多行写，编译器更喜欢、你也更不会搞错
3. 隐式转换要心中有数——窄转宽安全、宽转窄必须用 static_cast 说清楚

容易踩的坑

小结

• 运算符优先级和结合律决定了复杂表达式里的运算顺序——乘除优先于加减，同级从左到右，赋值和一元右结合
• 前置 ++i 和后置 i++ 对变量最终值的影响相同，但子表达式的返回值不同——前缀返回新值、后缀返回旧值
• 不同类型出现在同一表达式里会触发隐式转换——窄类型自动转宽类型，逆方向需要用 static_cast 显式转换
• 为避免未定义行为，不要在一条表达式里多次修改同一个变量
• 不确定运算顺序时——加括号；不确定类型转换方向时——用 static_cast；表达式太长拆成多行——清晰永远比聪明重要

#include <iostream>
int main() {
    int i = 3;
    int j = ++i * i++ + i;   // 问题 1
    unsigned int u = 5;
    int n = -2;
    std::cout << u + n << std::endl;  // 问题 2
    return 0;
}

#include <iostream>
int main() {
    int i = 3;
    int a = ++i;       // i=4, a=4
    int b = i++;       // 返回 4, i=5, b=4
    int j = a * b + i; // 4*4+5 = 21, 清晰明确！
    unsigned int u = 5;
    int n = -2;
    std::cout << static_cast<int>(u) + n << std::endl; // 结果 3
    return 0;
}

#include <iostream>
int main() {
    std::cout << 6 % 4 << std::endl;     // ①
    std::cout << -6 % 4 << std::endl;    // ②
    std::cout << 6 % -4 << std::endl;    // ③
    return 0;
}

#include <iostream>
int main() {
    int a = 10, b = 3;
    std::cout << a / b << std::endl;    // ①
    std::cout << a % b << std::endl;    // ②
    a += b++ * 2;
    std::cout << a << std::endl;        // ③
    std::cout << b << std::endl;        // ④
    a = static_cast<double>(a) / 3;
    std::cout << a << std::endl;        // ⑤
    return 0;
}