《C++ Primer》导学系列：第 4 章 - 表达式

本文链接：https://blog.csdn.net/iShare_Carlos/article/details/139740987

4.1 基础

4.1.1 基本概念

组合运算符和运算对象

组合运算符是指将两个或多个操作数结合在一起进行运算的符号。在C++中，常见的组合运算符包括算术运算符（如+, -, *, /, %）、关系运算符（如<, >, <=, >=, ==, !=）和逻辑运算符（如&&, ||, !）等。

示例：

int a = 5, b = 10;
int sum = a + b;  // '+' 是一个组合运算符，a 和 b 是运算对象

运算对象转换

在表达式中，不同类型的运算对象在进行运算时，可能会自动转换为同一类型，以确保运算的正确性。这种转换可以是隐式转换或显式转换。

隐式转换：

int a = 5;
double b = 3.2;
double result = a + b;  // a 自动转换为 double 类型

显式转换：

double pi = 3.14;
int int_pi = static_cast<int>(pi);  // 使用 static_cast 进行显式转换

重载运算符

C++允许用户定义的类型重载运算符。重载运算符使用户定义的类型能够像内置类型一样进行运算。例如，可以为类定义+运算符以实现两个对象的相加。

左值和右值

左值（lvalue）表示一个对象的身份，可以位于赋值运算符的左侧。右值（rvalue）表示一个对象的值，通常位于赋值运算符的右侧，右值通常是一个“将亡值”，一般情况下不能够获取到它的地址。

4.1.2 优先级与结合律

运算符的优先级决定了表达式中运算符的计算顺序。结合律决定了具有相同优先级的运算符的结合顺序。

优先级

优先级高的运算符先计算。例如，乘法运算符*的优先级高于加法运算符+，因此在表达式a + b * c中，b * c会先计算。

示例：

int a = 5, b = 10, c = 3;
int result = a + b * c;  // 先计算 b * c，然后计算 a + (b * c)

结合律

结合律分为左结合和右结合。左结合表示从左到右进行计算，右结合表示从右到左进行计算。例如，赋值运算符=是右结合的，而加法运算符+是左结合的。

示例：

int a = 5, b = 10, c = 15;
int result = a - b + c;  // 先计算 a - b，然后计算 (a - b) + c，左结合

4.1.3 求值顺序

求值顺序与运算符的优先级和结合律密切相关，但并不是完全由优先级和结合律决定。C++标准并不严格规定所有表达式的求值顺序，这可能导致某些情况下的未定义行为。

运算符的优先级和结合律的关系

优先级决定了哪些运算符先计算，而结合律决定了相同优先级的运算符的计算顺序。理解优先级和结合律有助于正确分析和编写复杂表达式。

示例：

int a = 1, b = 2, c = 3;
int result = a + b * c;  // 先计算 b * c（优先级高），然后计算 a + (b * c)

未定义的求值顺序

有些表达式的求值顺序未定义，特别是涉及到副作用的表达式。这可能导致不同编译器生成不同的结果，因此编写代码时应避免这种情况。

示例：

int i = 0;
int result = i++ + ++i;  // 未定义行为，不同编译器可能产生不同结果

为了确保表达式的求值顺序明确，可以使用括号或将复杂表达式分解为简单的子表达式。

示例：

int i = 0;
int temp1 = i++;
int temp2 = ++i;
int result = temp1 + temp2;  // 确保求值顺序明确

重点与难点分析

重点：

组合运算符和运算对象：理解组合运算符如何操作不同类型的运算对象，以及它们在表达式中的作用。
运算对象转换：掌握隐式和显式类型转换，了解它们在表达式计算中的应用。
重载运算符：理解运算符重载的概念，并能够在自定义类型中实现运算符重载。
左值和右值：熟悉左值和右值的概念，理解它们在表达式和赋值中的角色。
优先级与结合律：掌握运算符优先级和结合律对表达式求值顺序的影响。
求值顺序：了解求值顺序的概念，避免未定义行为。

难点：

复杂表达式的分析：初学者需要通过实践理解复杂表达式中运算符的优先级和结合律。
未定义的求值顺序：在编写涉及副作用的表达式时，确保求值顺序明确，避免潜在的未定义行为。
重载运算符的实现：掌握在自定义类型中实现运算符重载的方法和最佳实践。

练习题解析

练习4.1：定义两个变量，编写包含组合运算符的表达式，输出结果。

- 示例代码：

#include <iostream>

int main() {
    int a = 5;
    int b = 10;
    int result = a + b * 2;  // 乘法优先于加法

    std::cout << "result: " << result << std::endl;  // 输出 25
    return 0;
}

练习4.2：编写包含隐式类型转换和显式类型转换的表达式，输出结果。

- 示例代码：

#include <iostream>

int main() {
    int a = 5;
    double b = 3.14;
    double result1 = a + b;  // 隐式转换
    int result2 = static_cast<int>(b);  // 显式转换

    std::cout << "result1: " << result1 << std::endl;  // 输出 8.14
    std::cout << "result2: " << result2 << std::endl;  // 输出 3
    return 0;
}

练习4.3：为一个类定义重载运算符，编写使用该运算符的表达式，输出结果。

- 示例代码：

#include <iostream>

class Complex {
public:
Complex(double r, double i) : re(r), im(i) {}
Complex operator+(const Complex& other) const {
    return Complex(re + other.re, im + other.im);
}
void print() const {
    std::cout << "Complex(" << re << ", " << im << ")" << std::endl;
}
private:
double re, im;
};

int main() {
    Complex a(1.0, 2.0);
    Complex b(2.0, 3.0);
    Complex c = a + b;  // 使用重载的 '+' 运算符

    c.print();  // 输出 Complex(3.0, 5.0)
    return 0;
}

练习4.4：编写包含优先级和结合律的复杂表达式，使用括号确保计算顺序，输出结果。

- 示例代码：

#include <iostream>

int main() {
    int a = 5;
    int b = 10;
    int c = 3;
    int result = (a + b) * c;  // 使用括号改变优先级

    std::cout << "result: " << result << std::endl;  // 输出 45
    return 0;
}

总结与提高

本节总结：

了解了组合运算符和运算对象的基本概念，掌握了运算对象在表达式中的作用。
掌握了隐式和显式类型转换，理解了它们在表达式计算中的应用。
学习了运算符重载的概念，并能够在自定义类型中实现运算符重载。
理解了左值和右值的概念，掌握了它们在表达式和赋值中的角色。
了解了运算符优先级和结合律的基本知识，并能够应用这些概念分析复杂表达式。
理解了求值顺序的重要性，避免未定义行为。

提高建议：

多练习表达式的编写和分析：通过编写各种包含不同运算符的表达式，熟悉运算符优先级和结合律。
深入理解类型转换：通过实践掌握隐式和显式类型转换的应用，特别是C++风格的类型转换。
重载运算符的实践：在自定义类型中实现常见的运算符重载，理解运算符重载的实现细节和最佳实践。
避免未定义的求值顺序：在编写涉及副作用的表达式时，使用括号确保求值顺序明确，避免潜在的未定义行为。
优化代码的可读性和可维护性：合理使用运算符优先级和结合律，提高代码的可读性和可维护性，确保代码逻辑清晰。

4.2 算术运算符

概述

算术运算符是最基本的运算符，用于执行基本的数学运算。C++ 提供了一组常用的算术运算符，包括加法、减法、乘法、除法和取余运算符。这些运算符的使用方法类似于我们在数学中使用它们的方式。

4.2.1 加法运算符（+）

加法运算符用于对两个数值进行加法运算。它的操作数可以是整数或浮点数，结果类型与操作数类型一致。

示例：

int a = 5, b = 3;
int sum = a + b;  // sum 的值为 8

double x = 2.5, y = 4.0;
double result = x + y;  // result 的值为 6.5

4.2.2 减法运算符（-）

减法运算符用于对两个数值进行减法运算。它的操作数可以是整数或浮点数，结果类型与操作数类型一致。

示例：

int a = 5, b = 3;
int difference = a - b;  // difference 的值为 2

double x = 5.5, y = 2.0;
double result = x - y;  // result 的值为 3.5

4.2.3 乘法运算符（*）

乘法运算符用于对两个数值进行乘法运算。它的操作数可以是整数或浮点数，结果类型与操作数类型一致。

示例：

int a = 5, b = 3;
int product = a * b;  // product 的值为 15

double x = 2.5, y = 4.0;
double result = x * y;  // result 的值为 10.0

4.2.4 除法运算符（/）

除法运算符用于对两个数值进行除法运算。对于整数除法，结果是去掉小数部分的整数；对于浮点数除法，结果是包含小数部分的浮点数。

示例：

int a = 10, b = 3;
int quotient = a / b;  // quotient 的值为 3

double x = 10.0, y = 4.0;
double result = x / y;  // result 的值为 2.5

注意整数除法

在整数除法中，如果除不尽会舍弃小数部分。因此需要特别注意整数除法的结果。

示例：

int a = 10, b = 3;
double result = a / b;  // result 的值为 3.0，而不是 3.333...

为了得到精确的浮点数结果，需要将操作数转换为浮点数类型。

示例：

int a = 10, b = 3;
double result = static_cast<double>(a) / b;  // result 的值为 3.333...

4.2.5 取余运算符（%）

取余运算符用于获取两个整数相除后的余数。它只能用于整数操作数。

示例：

int a = 10, b = 3;
int remainder = a % b;  // remainder 的值为 1

使用取余运算符判断奇偶性

取余运算符可以用于判断一个数是奇数还是偶数。

示例：

int number = 5;
if (number % 2 == 0) {
    std::cout << "Even" << std::endl;
} else {
    std::cout << "Odd" << std::endl;
}

重点与难点分析

重点：

算术运算符的基本用法：掌握加法、减法、乘法、除法和取余运算符的基本用法。
整数除法的注意事项：理解整数除法的结果特性，特别是舍弃小数部分的行为。
使用取余运算符判断奇偶性：了解如何使用取余运算符判断一个数是奇数还是偶数。

难点：

复杂表达式的求值顺序：初学者需要通过实践理解如何根据运算符优先级和结合性计算复杂表达式的值。
整数除法与浮点数除法的区别：理解并掌握整数除法和浮点数除法之间的区别及其应用场景。

练习题解析

练习4.5：定义两个整数变量，分别执行加法、减法、乘法、除法和取余运算，输出结果。

- 示例代码：

#include <iostream>

int main() {
    int a = 10, b = 3;
    std::cout << "a + b = " << a + b << std::endl;
    std::cout << "a - b = " << a - b << std::endl;
    std::cout << "a * b = " << a * b << std::endl;
    std::cout << "a / b = " << a / b << std::endl;
    std::cout << "a % b = " << a % b << std::endl;

    return 0;
}

练习4.6：编写一个程序，判断一个整数是奇数还是偶数，并输出结果。

- 示例代码：

#include <iostream>

int main() {
    int number;
    std::cout << "Enter an integer: ";
    std::cin >> number;

    if (number % 2 == 0) {
        std::cout << number << " is even." << std::endl;
    } else {
        std::cout << number << " is odd." << std::endl;
    }

    return 0;
}

总结与提高

本节总结：

了解了算术运算符的基本用法，包括加法、减法、乘法、除法和取余运算符。
理解了整数除法的特性，特别是舍弃小数部分的行为，以及如何将整数除法转换为浮点数除法。
掌握了使用取余运算符判断奇偶性的方法。

提高建议：

多练习算术运算符的基本操作：通过编写各种算术运算的小程序，熟悉加法、减法、乘法、除法和取余运算符的用法。
深入理解整数除法与浮点数除法的区别：通过实践理解整数除法和浮点数除法之间的区别及其应用场景。
应用算术运算符优化代码：在实际编程中，合理使用算术运算符优化代码，提高代码的可读性和执行效率。

4.3 逻辑和关系运算符

概述

逻辑运算符和关系运算符是C++中用于控制程序流程的重要工具。逻辑运算符用于执行布尔逻辑运算，关系运算符用于比较两个值。理解和正确使用这些运算符是编写条件判断和控制结构的基础。

4.3.1 关系运算符

关系运算符用于比较两个运算对象，返回一个布尔值true或false。常见的关系运算符包括：

等于运算符（==）：检查两个值是否相等。
不等于运算符（!=）：检查两个值是否不相等。
大于运算符（>）：检查左侧值是否大于右侧值。
小于运算符（<）：检查左侧值是否小于右侧值。
大于等于运算符（>=）：检查左侧值是否大于或等于右侧值。
小于等于运算符（<=）：检查左侧值是否小于或等于右侧值。

4.3.2 逻辑运算符

逻辑运算符用于执行布尔逻辑运算，常见的逻辑运算符包括：

逻辑与运算符（&&）：当且仅当两个操作数都为true时，结果才为true。
逻辑或运算符（||）：当且仅当两个操作数至少有一个为true时，结果为true。
逻辑非运算符（!）：将布尔值取反，true变为false，false变为true。

4.3.3 组合使用关系运算符和逻辑运算符

在实际编程中，关系运算符和逻辑运算符经常组合使用，以实现复杂的条件判断。

示例代码

#include <iostream>

int main() {
    int x = 5, y = 10, z = 15;

    // 组合使用关系运算符和逻辑运算符
    if (x < y && y < z) {
        std::cout << "x < y < z" << std::endl;
    } else {
        std::cout << "Condition not met" << std::endl;
    }

    return 0;
}

4.3.4 逻辑运算符的短路求值

逻辑运算符具有短路求值的特性，即如果逻辑表达式的最终结果已经确定，则不会计算剩余部分。这在提高程序效率和避免不必要的计算方面非常有用。

示例代码

#include <iostream>

bool is_positive(int n) {
    std::cout << "Checking if positive..." << std::endl;
    return n > 0;
}

int main() {
    int x = -5;

    // 短路求值示例
    if (x > 0 && is_positive(x)) {
        std::cout << "x is positive" << std::endl;
    } else {
        std::cout << "x is not positive" << std::endl;
    }

    return 0;
}

在上面的示例中，如果x > 0为false，则is_positive(x)将不会被调用，因为整个逻辑表达式的结果已经确定为false。