第6章：表达式与赋值语句（Expressions and Assignment Statements）

一、导读

1.1 学习目标

本章深入探讨程序中表达式和赋值语句的构成与求值机制。通过本章学习，读者应当能够：理解表达式的组成要素及其求值过程；掌握运算符优先级和结合性的概念及其对程序行为的影响；认识求值顺序的重要性及其在不同语言中的差异；理解副作用的概念及其对程序正确性的影响；了解赋值语句的各种形式及其语义差异。

1.2 表达式在程序设计中的地位

表达式（Expression）是程序中最基本的计算单元。从简单的算术运算到复杂的函数调用链，程序的计算逻辑本质上是通过组合各种表达式来实现的。表达式的設計直接影响语言的表达能力和代码的可读性。在某些语言（如Haskell、Rust）中，几乎所有构造都是表达式，都有返回值；而在另一些语言（如早期BASIC）中，表达式和语句的界限更加分明。

1.3 赋值与状态变更

赋值语句（Assignment Statement）是命令式编程中改变程序状态的基本手段。通过将表达式的计算结果存储到变量中，程序能够记住中间结果、累积计算状态。赋值语句的设计涉及类型兼容性、内存管理、别名问题等深层语义问题，是语言设计中需要仔细权衡的方面。

二、核心概念详解

2.1 表达式的组成与分类

表达式由操作数（Operands）和运算符（Operators）组成，通过递归组合形成复杂的计算逻辑。

操作数 是表达式的值来源，可以是字面量（如 42、"hello"、true）、变量引用（如 x、count）、数组元素访问（如 arr[i]）、对象属性访问（如 obj.field）或函数调用（如 f(x)）。操作数具有类型，其类型决定了可以对其执行哪些运算。

运算符 是对操作数执行操作的符号。按照操作数数量分为一元运算符（如 -x、!flag、++i）、二元运算符（如 a + b、x * y、a && b）和三元运算符（如 condition ? a : b）。按照功能分为算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符和条件运算符等。

表达式的类型 由操作数的类型和运算符的语义共同决定。类型规则定义了哪些类型组合是合法的，以及表达式的结果类型是什么。例如，在强类型语言中，"hello" + 42 可能是类型错误；在弱类型语言中，可能通过隐式转换得到 "hello42"。

纯表达式与不纯表达式：纯表达式（Pure Expression）的求值只取决于操作数的值，不产生副作用，如 2 + 3 总是返回 5。不纯表达式（Impure Expression）的求值可能产生副作用或依赖外部状态，如 x++ 修改了 x 的值，readLine() 依赖用户输入。纯表达式更容易推理和优化，是函数式编程追求的目标。

2.2 运算符优先级与结合性

当表达式中包含多个运算符时，需要规则来确定计算顺序。

运算符优先级（Operator Precedence） 决定了不同运算符之间的计算先后关系。高优先级运算符先于低优先级运算符计算。例如，在大多数语言中，乘法 * 的优先级高于加法 +，所以 2 + 3 * 4 的计算结果是 14 而非 20。

典型的运算符优先级从高到低为：括号 > 一元运算符 > 算术运算符（先乘除后加减）> 关系运算符 > 逻辑运算符（先AND后OR）> 赋值运算符。不同语言的具体优先级表可能有所不同，这导致在跨语言编程时需要特别注意。

运算符结合性（Operator Associativity） 决定了相同优先级运算符的计算方向。左结合（Left Associative）运算符从左到右计算，如 a - b - c 等价于 (a - b) - c。右结合（Right Associative）运算符从右到左计算，如赋值运算符 a = b = c 等价于 a = (b = c)，指数运算 a ^ b ^ c 在某些语言中等价于 a ^ (b ^ c)。

使用括号明确意图：虽然优先级和结合性规则确保了表达式的求值是确定的，但过度依赖这些规则会降低代码可读性。在复杂表达式中使用括号明确计算顺序是良好的编程习惯，即使括号在技术上是多余的。

2.3 求值顺序

求值顺序（Evaluation Order）决定了表达式中各子表达式被计算的先后次序。这是一个经常被忽视但极其重要的概念。

运算符优先级不等于求值顺序。优先级决定了哪些操作数属于哪个运算符，但不决定操作数本身的求值顺序。例如，在 f() + g() * h() 中，优先级确定了 g() * h() 先于加法计算，但 f()、g()、h() 三个函数的调用顺序可能因语言而异。

不同语言的求值顺序保证：

C和C++：大多数情况下求值顺序未指定（Unspecified），编译器可以自由选择。这导致了著名的未定义行为问题，如 i = i++ + ++i。
Java：保证从左到右的求值顺序。
Python：保证从左到右的求值顺序。
C#：保证从左到右的求值顺序。
Haskell：默认惰性求值，只在需要时才计算表达式。

短路求值（Short-Circuit Evaluation） 是逻辑运算符的特殊求值规则。&& 运算符在左操作数为 false 时不再求值右操作数，|| 运算符在左操作数为 true 时不再求值右操作数。短路求值不仅是一种优化，还被广泛用于条件判断中，如 ptr != null && ptr->value > 0。

2.4 副作用

副作用（Side Effect）是指表达式求值过程中对程序状态产生的可观测影响。常见的副作用包括：修改变量的值、执行I/O操作、修改对象的状态、抛出异常等。

副作用的存在使得程序的推理变得复杂。一个带有副作用的表达式不仅产生一个值，还改变了程序的状态。这意味着同一个表达式在不同的执行时刻可能产生不同的效果，取决于它被求值时程序的状态。

引用透明性（Referential Transparency） 是函数式编程的核心概念。一个表达式是引用透明的，如果它可以被其值替换而不改变程序的行为。纯表达式是引用透明的，带有副作用的表达式则不是。引用透明性使得等式推理成为可能，极大地简化了程序的验证和优化。

纯函数式语言（如Haskell）通过类型系统将副作用与纯计算严格分离。IO操作被封装在 IO 类型中，编译器可以区分纯计算和副作用操作。这种设计使得程序的推理和测试变得更加容易。

2.5 赋值语句的语义

赋值语句将表达式的计算结果存储到变量或内存位置中，是命令式编程中改变程序状态的基本手段。

简单赋值 将一个值赋给单个变量，如 x = 5。赋值的语义涉及左值（L-value，赋值的目标）和右值（R-value，赋值的来源）的概念。左值必须是可修改的存储位置，右值是可以产生值的表达式。

复合赋值 将运算与赋值结合，如 x += 5 等价于 x = x + 5（但在某些语言中语义略有不同，x += 5 只求值 x 一次）。常见的复合赋值包括 +=、-=、*=、/=、%= 等。

赋值语义的差异：在不同语言中，赋值操作的含义可能截然不同。在C/Java中，赋值是值的复制，赋值后两个变量独立变化。在Python中，赋值是名称绑定，赋值后两个名称指向同一个对象。在JavaScript中，基本类型赋值是值复制，对象类型赋值是引用复制。这些差异直接影响程序的行为。

多重赋值 允许同时为多个变量赋值。Python支持元组解包赋值 a, b = b, a（交换两个变量的值），Go支持多返回值赋值 result, err := doSomething()。多重赋值提升了代码的简洁性和表达力。

三、深入分析

3.1 左值与右值

左值（L-value）和右值（R-value）是理解赋值语义的关键概念。

左值指代一个具有持久存储位置的表达式，可以出现在赋值运算符的左侧。变量名、数组元素、对象属性都是左值。字面量和临时表达式不是左值，因为它们不对应可修改的存储位置。

右值指代一个值本身，可以出现在赋值运算符的右侧。任何表达式都是右值，包括左值（左值在需要值的位置会自动转换为右值）。

C++11引入了右值引用（R-value Reference） 的概念，使用 && 语法。右值引用允许区分临时对象和持久对象，从而实现移动语义（Move Semantics）。移动语义使得资源的转移（而非复制）成为可能，大幅提升了性能：

cpp

std::string a = "hello";
std::string b = std::move(a);  // 移动而非复制，a 变为有效但未定义状态

3.2 表达式中的类型转换

当运算符的操作数类型不一致时，语言需要决定如何处理类型不匹配。

隐式类型转换（Implicit Conversion） 由编译器自动执行。C/Java中的扩展转换（如 int 到 double）通常是安全的，因为不会丢失信息。缩窄转换（如 double 到 int）可能丢失精度，某些语言会发出警告。JavaScript的隐式转换规则极其复杂，是许多bug的来源。

显式类型转换（Explicit Conversion / Casting） 由程序员通过语法明确指定。如 (int)3.14 将浮点数截断为整数，String.valueOf(42) 将整数转换为字符串。显式转换表达了程序员的明确意图，比隐式转换更加安全和清晰。

类型强制（Coercion） 是运算符自动对其操作数进行的隐式转换。例如，在 3 + 4.5 中，整数 3 被强制转换为浮点数 3.0，然后执行浮点加法。类型强制规则是语言语义的重要组成部分。

四、实践案例

4.1 案例一：求值顺序导致的bug

以下C语言代码展示了未定义求值顺序带来的问题：

int i = 0;
int a[3] = {0, 0, 0};
a[i++] = i;  // 未定义行为：i++ 和 a[i] 中的 i 的求值顺序未指定

如果 a[i] 先求值，则 i 为0，等价于 a[0] = 1（因为 i++ 返回0然后 i 变为1）。如果 i++ 先求值，则 i 变为1，等价于 a[1] = 1。由于C标准未指定求值顺序，不同的编译器可能产生不同的结果。

正确的做法是将副作用分离到独立的语句中：

int i = 0;
int a[3] = {0, 0, 0};
a[i] = i + 1;
i++;

4.2 案例二：赋值语义的差异

考虑以下Python代码：

python

a = [1, 2, 3]
b = a
b.append(4)
print(a)  # 输出 [1, 2, 3, 4]

在Python中，b = a 不是值的复制，而是名称绑定——b 和 a 指向同一个列表对象。修改 b 所指向的对象也会影响到 a。

如果需要独立的副本，需要显式复制：

python

a = [1, 2, 3]
b = a.copy()  # 或 b = a[:]
b.append(4)
print(a)  # 输出 [1, 2, 3]

这种赋值语义的差异是跨语言编程时常见的陷阱。理解不同语言的赋值模型（值语义 vs 引用语义）对于正确编写程序至关重要。

五、常见误区

5.1 误区一：优先级高的运算符一定先求值

运算符优先级决定的是操作数的归属关系，不是求值的时间顺序。在 f() + g() * h() 中，虽然 * 的优先级高于 +，但 f() 可能在 g() 和 h() 之前被调用。优先级确定的是语法树的形状，求值顺序确定的是遍历语法树的次序，两者是独立的概念。

5.2 误区二：赋值就是复制

在许多现代语言中，赋值并非简单的值复制。Python中的赋值是名称绑定，JavaScript中对象的赋值是引用复制，Rust中的赋值可能涉及所有权的转移。即使在C语言中，结构体的赋值虽然是值复制，但复制的是整个结构体的内容，而非指针。理解赋值的确切语义对于避免别名问题和内存管理错误至关重要。

5.3 误区三：表达式越复杂越好

复杂的嵌套表达式虽然简洁，但往往牺牲了可读性。一个包含多层三元运算符、复合赋值和函数调用的表达式可能需要花费大量时间来理解其含义。将复杂表达式拆分为多个简单的语句，使用有意义的中间变量名，通常能够提高代码的可读性和可维护性。

5.4 误区四：副作用是不可避免的

虽然命令式编程中副作用无处不在，但函数式编程证明了大规模减少副作用是可行的。通过将副作用限制在程序的边界（如I/O操作），将核心逻辑保持为纯函数，我们可以获得更好的可测试性、可推理性和并发安全性。Haskell、Elm等语言展示了这种编程风格的实际可行性。

六、本章小结

本章系统讲解了表达式和赋值语句的基本概念与求值机制。表达式通过组合操作数和运算符形成计算逻辑，其类型由操作数类型和运算符语义共同决定。运算符优先级和结合性规则确保了表达式求值的确定性，但优先级不等于求值顺序——后者在不同语言中有不同的保证。副作用使得表达式的推理变得复杂，引用透明性是函数式编程追求的理想特性。赋值语句将计算结果持久化到存储位置，其语义在不同语言中存在显著差异——值复制、引用绑定和所有权转移各有其特点。理解这些概念有助于我们编写清晰、高效的计算代码，避免常见的求值顺序陷阱和赋值语义误解，并为后续学习控制流和子程序设计奠定基础。

七、思考题

请列出你熟悉的编程语言中运算符的优先级表（至少8个级别），并指出哪些运算符的优先级最容易引起混淆。

什么是副作用？请举例说明带有副作用的表达式如何使程序推理变得复杂，以及减少副作用的好处。

比较Python、JavaScript和Rust三种语言中赋值操作的语义差异。这些差异如何影响了各自的最佳实践？

为什么C/C++标准选择不规定某些表达式的求值顺序？这种设计决策有什么优缺点？

请解释引用透明性的概念，并说明为什么函数式编程语言如此重视这一特性。在实际编程中，你能想到哪些使表达式变得不引用透明的常见原因？