实现 C++ 运算符

简介

在本实验中，你将学习如何实现各种 C++ 运算符，包括基本数学运算、递增/递减、关系运算符和逻辑运算符、位运算、复合赋值、运算顺序以及三元条件运算符。这些基础运算符对于在 C++ 编程中执行算术运算、进行比较以及操作数据至关重要。通过一系列实践练习，你将深入了解如何有效利用这些运算符来构建更复杂和高效的 C++ 应用程序。

Skills Graph

执行基本数学运算 (+, -, *, /, %)

在这一步中，你将学习如何在 C++ 中执行基本的数学运算。数学运算是编程的基础，允许你使用标准的算术运算符来操作数值。

打开 WebIDE，在 ~/project 目录下创建一个名为 math_operations.cpp 的新文件：

touch ~/project/math_operations.cpp

将以下代码添加到 math_operations.cpp 文件中：

#include <iostream>

int main() {
    // 声明用于数学运算的变量
    int a = 10;
    int b = 3;

    // 加法 (+)
    int sum = a + b;
    std::cout << "Addition: " << a << " + " << b << " = " << sum << std::endl;

    // 减法 (-)
    int difference = a - b;
    std::cout << "Subtraction: " << a << " - " << b << " = " << difference << std::endl;

    // 乘法 (*)
    int product = a * b;
    std::cout << "Multiplication: " << a << " * " << b << " = " << product << std::endl;

    // 除法 (/)
    int quotient = a / b;
    std::cout << "Division: " << a << " / " << b << " = " << quotient << std::endl;

    // 取模 (%) - 除法的余数
    int remainder = a % b;
    std::cout << "Modulus: " << a << " % " << b << " = " << remainder << std::endl;

    return 0;
}

编译并运行程序：

g++ math_operations.cpp -o math_operations
./math_operations

示例输出：

Addition: 10 + 3 = 13
Subtraction: 10 - 3 = 7
Multiplication: 10 * 3 = 30
Division: 10 / 3 = 3
Modulus: 10 % 3 = 1

让我们分解这些数学运算符：

1. + (加法)：将两个数字相加。例如，5 + 3 的结果是 8。
2. - (减法)：从第一个数字中减去第二个数字。例如，10 - 4 的结果是 6。
3. * (乘法)：将两个数字相乘。例如，6 * 7 的结果是 42。
4. / (除法)：将第一个数字除以第二个数字。当两个数字都是整数时，结果为整数除法，即小数部分被截断。例如，10 / 3 的结果是 3。
5. % (取模)：返回除法的余数。例如，10 % 3 的结果是 1，因为 10 除以 3 的余数是 1。

一些重要注意事项：

• 整数除法会截断小数部分。例如，5 / 2 的结果是 2，而不是 2.5。
• 取模运算符仅适用于整数类型。不能将其用于浮点数（如 float 或 double）。
• 始终注意除以零的情况，这会导致运行时错误。如果尝试将任何数字除以零，程序将崩溃。

使用前置和后置递增/递减 (++i, i++)

在这一步中，你将学习 C++ 中的递增和递减运算符。这些运算符允许你将变量的值增加或减少 1，前置递增和后置递增之间存在细微差别。

打开 WebIDE，在 ~/project 目录下创建一个名为 increment_decrement.cpp 的新文件：

touch ~/project/increment_decrement.cpp

将以下代码添加到 increment_decrement.cpp 文件中：

#include <iostream>

int main() {
    // 前置递增 (++i)
    int a = 5;
    std::cout << "Original value of a: " << a << std::endl;

    // 前置递增：在值被使用之前递增
    std::cout << "Pre-increment (++a): " << ++a << std::endl;
    std::cout << "Value after pre-increment: " << a << std::endl;

    // 后置递增 (i++)
    int b = 5;
    std::cout << "\nOriginal value of b: " << b << std::endl;

    // 后置递增：在值被使用之后递增
    std::cout << "Post-increment (b++): " << b++ << std::endl;
    std::cout << "Value after post-increment: " << b << std::endl;

    // 递减运算符的工作原理类似
    int c = 5;
    std::cout << "\nPre-decrement (--c): " << --c << std::endl;

    int d = 5;
    std::cout << "Post-decrement (d--): " << d-- << std::endl;
    std::cout << "Value after post-decrement: " << d << std::endl;

    return 0;
}

编译并运行程序：

g++ increment_decrement.cpp -o increment_decrement
./increment_decrement

示例输出：

Original value of a: 5
Pre-increment (++a): 6
Value after pre-increment: 6

Original value of b: 5
Post-increment (b++): 5
Value after post-increment: 6

Pre-decrement (--c): 4
Post-decrement (d--): 5
Value after post-decrement: 4

关键区别：

• 前置递增 ++i： 在值被用于表达式 之前 递增。在代码示例中，++a 首先将 a 递增到 6，然后在 cout 语句中使用值 6。
• 后置递增 i++： 首先在表达式中使用当前值，然后再递增。在代码示例中，b++ 首先在 cout 语句中使用 b 的当前值 5，然后将 b 递增到 6。

同样的原理适用于递减运算符 --i 和 i--，其中 --i 先递减再使用值，而 i-- 先使用值再递减。

重要注意事项：

• 前置递增在值被用于表达式之前改变值，这意味着递增后的值可以立即使用。
• 后置递增首先使用原始值，然后再递增。这意味着在当前语句中你会得到原始值，而在下一个语句中会得到递增后的值。
• 这些运算符通常用于循环（如 for 循环）和复杂表达式中，你希望在修改变量的同时使用其值。
• 在使用这些运算符时，尤其是在复杂表达式中，务必注意是否需要前置或后置版本来实现预期的行为。

使用关系运算符比较值 (<, >, ==, !=)

在这一步中，你将学习 C++ 中的关系运算符。这些运算符帮助你比较值并确定不同数字或变量之间的关系。

打开 WebIDE，在 ~/project 目录下创建一个名为 relational_operators.cpp 的新文件：

touch ~/project/relational_operators.cpp

将以下代码添加到 relational_operators.cpp 文件中：

#include <iostream>

int main() {
    int a = 10;
    int b = 5;
    int c = 10;

    // 小于 (<)
    std::cout << "Less than (<):" << std::endl;
    std::cout << a << " < " << b << " is " << (a < b) << std::endl;
    std::cout << b << " < " << a << " is " << (b < a) << std::endl;

    // 大于 (>)
    std::cout << "\nGreater than (>):" << std::endl;
    std::cout << a << " > " << b << " is " << (a > b) << std::endl;
    std::cout << b << " > " << a << " is " << (b > a) << std::endl;

    // 等于 (==)
    std::cout << "\nEqual to (==):" << std::endl;
    std::cout << a << " == " << b << " is " << (a == b) << std::endl;
    std::cout << a << " == " << c << " is " << (a == c) << std::endl;

    // 不等于 (!=)
    std::cout << "\nNot equal to (!=):" << std::endl;
    std::cout << a << " != " << b << " is " << (a != b) << std::endl;
    std::cout << a << " != " << c << " is " << (a != c) << std::endl;

    return 0;
}

编译并运行程序：

g++ relational_operators.cpp -o relational_operators
./relational_operators

示例输出：

Less than (<):
10 < 5 is 0
5 < 10 is 1

Greater than (>):
10 > 5 is 1
5 > 10 is 0

Equal to (==):
10 == 5 is 0
10 == 10 is 1

Not equal to (!=):
10 != 5 is 1
10 != 10 is 0

关系运算符的关键点：

• < (小于)：检查左侧值是否小于右侧值。例如，5 < 10 为真（返回 1），而 10 < 5 为假（返回 0）。
• > (大于)：检查左侧值是否大于右侧值。例如，10 > 5 为真（返回 1），而 5 > 10 为假（返回 0）。
• == (等于)：检查两个值是否完全相等。例如，5 == 5 为真（返回 1），而 5 == 6 为假（返回 0）。
• != (不等于)：检查两个值是否不相等。例如，5 != 6 为真（返回 1），而 5 != 5 为假（返回 0）。
• 这些运算符返回 1（真）或 0（假）。在 C++ 中，1 表示真，0 表示假。这些值可以用于条件语句中。

重要注意事项：

• 关系运算符是创建条件语句的基础，允许你的程序根据比较结果做出决策。
• 它们总是返回一个布尔值，在 C++ 中由整数表示（1 表示真，0 表示假）。
• 这些运算符通常用于 if 语句、while 循环和 for 循环中，以控制程序的执行流程。

使用逻辑 AND (&&) 和 OR (||) 组合条件

在这一步中，你将学习如何在 C++ 中使用逻辑 AND (&&) 和 OR (||) 运算符组合多个条件。这些运算符通过评估多个条件，帮助你创建更复杂的条件语句。

打开 WebIDE，在 ~/project 目录下创建一个名为 logical_operators.cpp 的新文件：

touch ~/project/logical_operators.cpp

将以下代码添加到 logical_operators.cpp 文件中：

#include <iostream>

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

    // 逻辑 AND (&&) 运算符
    std::cout << "Logical AND (&&) operator:" << std::endl;

    // 两个条件都必须为真
    if (x > y && x < z) {
        std::cout << "x is greater than y AND less than z" << std::endl;
    }

    if (x > 20 && y < 10) {
        std::cout << "This will not be printed" << std::endl;
    }

    // 逻辑 OR (||) 运算符
    std::cout << "\nLogical OR (||) operator:" << std::endl;

    // 至少一个条件必须为真
    if (x > 20 || y < 10) {
        std::cout << "At least one condition is true" << std::endl;
    }

    if (x > 20 || z < 20) {
        std::cout << "Another true condition" << std::endl;
    }

    // 组合 AND 和 OR
    std::cout << "\nCombining AND and OR:" << std::endl;

    if ((x > y && y < z) || x == 10) {
        std::cout << "Complex condition is true" << std::endl;
    }

    return 0;
}

编译并运行程序：

g++ logical_operators.cpp -o logical_operators
./logical_operators

示例输出：

Logical AND (&&) operator:
x is greater than y AND less than z

Logical OR (||) operator:
At least one condition is true
Another true condition

Combining AND and OR:
Complex condition is true

逻辑运算符的关键点：

• && (AND)：连接的两个条件都必须为真，整个表达式才为真。如果任何一个条件为假，整个表达式将被评估为假。在代码中，x > y && x < z 为真，因为 x > y (10 > 5) 和 x < z (10 < 15) 都为真。
• || (OR)：连接的至少一个条件必须为真，整个表达式才为真。如果所有条件都为假，整个表达式将被评估为假。在代码中，x > 20 || y < 10 为真，因为 y < 10 (5 < 10) 为真。
• 你可以使用括号组合多个条件，以控制评估顺序。这使你的复杂表达式更易于阅读和理解。
• 这些运算符在条件语句中创建复杂的决策逻辑时非常有用。

重要注意事项：

• 逻辑运算符通常用于 if 语句、while 循环和其他控制流结构中，以使你的程序更加灵活。
• 它们通过允许你同时检查多个条件，帮助创建更复杂的条件检查。
• 短路评估：
  • 对于 &&，如果第一个条件为假，则不会评估第二个条件，因为无论第二个条件如何，整个表达式都将为假。这种优化可以提高性能。
  • 对于 ||，如果第一个条件为真，则不会评估第二个条件，因为无论第二个条件如何，整个表达式都将为真。

应用位运算进行二进制操作

在这一步中，你将学习 C++ 中的位运算符。这些运算符直接作用于整数的二进制表示，允许你操作单个位。

打开 WebIDE，在 ~/project 目录下创建一个名为 bitwise_operations.cpp 的新文件：

touch ~/project/bitwise_operations.cpp

将以下代码添加到 bitwise_operations.cpp 文件中：

#include <iostream>
#include <bitset>

int main() {
    // 数字的二进制表示
    unsigned int a = 5;   // 二进制 0101
    unsigned int b = 3;   // 二进制 0011

    // 位与运算 (&)
    std::cout << "Bitwise AND (&):" << std::endl;
    std::cout << "a = " << std::bitset<4>(a) << " (5 in decimal)" << std::endl;
    std::cout << "b = " << std::bitset<4>(b) << " (3 in decimal)" << std::endl;
    unsigned int and_result = a & b;
    std::cout << "a & b = " << std::bitset<4>(and_result)
              << " (" << and_result << " in decimal)" << std::endl;

    // 位或运算 (|)
    std::cout << "\nBitwise OR (|):" << std::endl;
    unsigned int or_result = a | b;
    std::cout << "a | b = " << std::bitset<4>(or_result)
              << " (" << or_result << " in decimal)" << std::endl;

    // 位异或运算 (^)
    std::cout << "\nBitwise XOR (^):" << std::endl;
    unsigned int xor_result = a ^ b;
    std::cout << "a ^ b = " << std::bitset<4>(xor_result)
              << " (" << xor_result << " in decimal)" << std::endl;

    // 位非运算 (~)
    std::cout << "\nBitwise NOT (~):" << std::endl;
    unsigned int not_result = ~a;
    std::cout << "~a = " << std::bitset<32>(not_result)
              << " (" << not_result << " in decimal)" << std::endl;

    // 左移运算 (<<)
    std::cout << "\nLeft Shift (<<):" << std::endl;
    unsigned int left_shift = a << 2;
    std::cout << "a << 2 = " << std::bitset<8>(left_shift)
              << " (" << left_shift << " in decimal)" << std::endl;

    // 右移运算 (>>)
    std::cout << "\nRight Shift (>>):" << std::endl;
    unsigned int right_shift = a >> 1;
    std::cout << "a >> 1 = " << std::bitset<4>(right_shift)
              << " (" << right_shift << " in decimal)" << std::endl;

    return 0;
}

编译并运行程序：

g++ bitwise_operations.cpp -o bitwise_operations
./bitwise_operations

示例输出：

Bitwise AND (&):
a = 0101 (5 in decimal)
b = 0011 (3 in decimal)
a & b = 0001 (1 in decimal)

Bitwise OR (|):
a | b = 0111 (7 in decimal)

Bitwise XOR (^):
a ^ b = 0110 (6 in decimal)

Bitwise NOT (~):
~a = 11111111111111111111111111111010 (4294967290 in decimal)

Left Shift (<<):
a << 2 = 00010100 (20 in decimal)

Right Shift (>>):
a >> 1 = 0010 (2 in decimal)

位运算符的关键点：

• & (AND)：比较两个数字的对应位。如果两个位都为 1，则结果位为 1；否则为 0。在代码示例中，5 & 3（二进制 0101 & 0011）的结果是 0001，即十进制的 1。
• | (OR)：比较两个数字的对应位。如果至少有一个位为 1，则结果位为 1；否则为 0。在示例中，5 | 3（二进制 0101 | 0011）的结果是 0111，即十进制的 7。
• ^ (XOR)：比较两个数字的对应位。如果位不同，则结果位为 1；否则为 0。在示例中，5 ^ 3（二进制 0101 ^ 0011）的结果是 0110，即十进制的 6。
• ~ (NOT)：反转数字的所有位。如果位为 1，则变为 0，反之亦然。注意，~a 的输出是 11111111111111111111111111111010，这是将数字视为 32 位无符号整数时的二进制表示。
• << (左移)：将数字的位向左移动指定的位数。每移动一位，数字实际上乘以 2。在示例中，5 << 2（二进制 0101 << 2）将位移动为 010100，即十进制的 20。
• >> (右移)：将数字的位向右移动指定的位数。每移动一位，数字实际上除以 2。在示例中，5 >> 1（二进制 0101 >> 1）将位移动为 0010，即十进制的 2。

重要注意事项：

• 位运算直接作用于整数的二进制表示，允许进行低级别的操作和优化。
• 它们通常用于嵌入式系统、图形编程以及需要设置、清除或测试值中单个位的场景。
• 注意有符号和无符号整数的区别，因为右移行为可能会有所不同（算术右移与逻辑右移）。
• 使用 std::bitset 可以帮助可视化这些操作在二进制级别的工作原理。

使用复合赋值运算符 (+=, -=, *=)

在这一步中，你将学习 C++ 中的复合赋值运算符。这些运算符将算术运算与赋值操作结合在一起，使你的代码更加简洁和易读。

打开 WebIDE，在 ~/project 目录下创建一个名为 compound_operators.cpp 的新文件：

touch ~/project/compound_operators.cpp

将以下代码添加到 compound_operators.cpp 文件中：

#include <iostream>

int main() {
    // 初始化变量
    int x = 10;
    int y = 5;

    // 加法赋值 (+=)
    std::cout << "Addition Assignment (+=):" << std::endl;
    std::cout << "Initial x: " << x << std::endl;
    x += 3;  // 等价于 x = x + 3
    std::cout << "x += 3: " << x << std::endl;

    // 减法赋值 (-=)
    std::cout << "\nSubtraction Assignment (-=):" << std::endl;
    std::cout << "Initial y: " << y << std::endl;
    y -= 2;  // 等价于 y = y - 2
    std::cout << "y -= 2: " << y << std::endl;

    // 乘法赋值 (*=)
    std::cout << "\nMultiplication Assignment (*=):" << std::endl;
    int z = 4;
    std::cout << "Initial z: " << z << std::endl;
    z *= 3;  // 等价于 z = z * 3
    std::cout << "z *= 3: " << z << std::endl;

    // 除法赋值 (/=)
    std::cout << "\nDivision Assignment (/=):" << std::endl;
    int a = 15;
    std::cout << "Initial a: " << a << std::endl;
    a /= 3;  // 等价于 a = a / 3
    std::cout << "a /= 3: " << a << std::endl;

    // 取模赋值 (%=)
    std::cout << "\nModulus Assignment (%=):" << std::endl;
    int b = 17;
    std::cout << "Initial b: " << b << std::endl;
    b %= 5;  // 等价于 b = b % 5
    std::cout << "b %= 5: " << b << std::endl;

    return 0;
}

编译并运行程序：

g++ compound_operators.cpp -o compound_operators
./compound_operators

示例输出：

Addition Assignment (+=):
Initial x: 10
x += 3: 13

Subtraction Assignment (-=):
Initial y: 5
y -= 2: 3

Multiplication Assignment (*=):
Initial z: 4
z *= 3: 12

Division Assignment (/=):
Initial a: 15
a /= 3: 5

Modulus Assignment (%=):
Initial b: 17
b %= 5: 2

复合赋值运算符的关键点：

• += (加并赋值)：将右操作数加到左操作数，并将结果赋值给左操作数。x += 3 等价于 x = x + 3。
• -= (减并赋值)：从左操作数中减去右操作数，并将结果赋值给左操作数。y -= 2 等价于 y = y - 2。
• *= (乘并赋值)：将左操作数乘以右操作数，并将结果赋值给左操作数。z *= 3 等价于 z = z * 3。
• /= (除并赋值)：将左操作数除以右操作数，并将结果赋值给左操作数。a /= 3 等价于 a = a / 3。
• %= (取模并赋值)：计算左操作数对右操作数取模的结果，并将结果赋值给左操作数。b %= 5 等价于 b = b % 5。

重要注意事项：

• 复合赋值运算符通过将操作和赋值结合为一步，使你的代码更加简洁和易读。
• 它们适用于所有基本算术运算 (+, -, *, /, %)。
• 它们可以减少输入量，使代码更短，并可能提高性能。

理解多运算符的运算顺序

在这一步中，你将学习 C++ 中的运算顺序，通常通过缩写 PEMDAS（括号、指数、乘法和除法、加法和减法）来记忆。理解这一顺序对于编写正确的数学表达式至关重要。

打开 WebIDE，在 ~/project 目录下创建一个名为 order_of_operations.cpp 的新文件：

touch ~/project/order_of_operations.cpp

将以下代码添加到 order_of_operations.cpp 文件中：

#include <iostream>

int main() {
    // 基本运算顺序演示
    int a = 10;
    int b = 5;
    int c = 3;

    // 乘法优先于加法
    std::cout << "Multiplication before Addition:" << std::endl;
    int result1 = a + b * c;
    std::cout << "a + b * c = " << result1 << std::endl;

    // 括号改变运算顺序
    std::cout << "\nParentheses change order:" << std::endl;
    int result2 = (a + b) * c;
    std::cout << "(a + b) * c = " << result2 << std::endl;

    // 包含多个运算符的复杂表达式
    std::cout << "\nComplex Expression:" << std::endl;
    int x = 4;
    int y = 2;
    int z = 3;

    int complex_result = x + y * z - (x / y);
    std::cout << "x + y * z - (x / y) = " << complex_result << std::endl;

    // 演示递增和乘法的优先级
    std::cout << "\nIncrement and Multiplication:" << std::endl;
    int m = 3;
    int n = 2;
    int precedence_result = m++ * n;
    std::cout << "m++ * n = " << precedence_result << std::endl;
    std::cout << "m after operation = " << m << std::endl;

    return 0;
}

编译并运行程序：

g++ order_of_operations.cpp -o order_of_operations
./order_of_operations

示例输出：

Multiplication before Addition:
a + b * c = 25

Parentheses change order:
(a + b) * c = 45

Complex Expression:
x + y * z - (x / y) = 8

Increment and Multiplication:
m++ * n = 6
m after operation = 4

关于运算顺序的关键点：

• 运算顺序，也称为运算符优先级，决定了表达式的求值方式。C++ 遵循数学规则进行运算。
• PEMDAS/BODMAS： 这是一个常见的记忆法：
  • Parentheses / Brackets（括号/方括号）：括号或方括号内的表达式首先被求值。
  • Exponents / Orders（指数/阶数）：指数或阶数（如平方根）接下来被求值，尽管 C++ 没有内置的指数运算符，但这一步指的是类似 pow() 的操作。
  • MD Multiplication and Division（乘法和除法）：乘法和除法具有相同的优先级，从左到右求值。
  • AS Addition and Subtraction（加法和减法）：加法和减法具有相同的优先级，从左到右求值。
• 在代码中，int result1 = a + b * c; 的求值结果为 10 + (5 * 3)，即 10 + 15 = 25，因为乘法的优先级高于加法。
• 括号可以覆盖默认的运算顺序，使表达式 int result2 = (a + b) * c; 的求值结果为 (10 + 5) * 3，即 15 * 3 = 45，因为括号内的表达式首先被计算。
• 递增/递减运算符具有特定的优先级规则，有时可能会令人困惑。在代码中使用的后置递增运算符 m++，首先使用 m 的原始值进行乘法运算 m * n，然后才递增变量 m。
• 在复杂表达式 x + y * z - (x / y) 中，乘法和除法优先于加法和减法。括号强制整数除法 x / y 首先进行。
• 始终使用括号来明确你的意图，尤其是在处理复杂表达式时。这不仅使代码更易读，还确保表达式按预期求值。

重要注意事项：

• PEMDAS/BODMAS 有助于预测表达式的求值方式，但请记住，C++ 没有内置的指数运算符。
• 如果有疑问，请使用括号明确定义顺序。这可以使你的代码更清晰，并防止由于误解优先级而导致的错误。
• 某些运算符具有相同的优先级，并从左到右求值。例如，a - b + c 中，减法将在加法之前进行。
• 在单个表达式中组合多个运算符时，请特别小心。如果不正确理解运算符优先级，可能会导致难以察觉的错误。

练习三元条件运算符

在这一步中，你将学习三元条件运算符，这是一种在一行中编写简单 if-else 语句的简洁方式。该运算符为代码中的决策提供了一种简洁的方法。

打开 WebIDE，在 ~/project 目录下创建一个名为 ternary_operator.cpp 的新文件：

touch ~/project/ternary_operator.cpp

将以下代码添加到 ternary_operator.cpp 文件中：

#include <iostream>

int main() {
    // 基本三元运算符语法
    // condition ? value_if_true : value_if_false

    // 简单比较
    int x = 10;
    int y = 5;

    // 确定较大的数字
    int max_value = (x > y) ? x : y;
    std::cout << "Larger value: " << max_value << std::endl;

    // 检查数字是偶数还是奇数
    int number = 7;
    std::string result = (number % 2 == 0) ? "Even" : "Odd";
    std::cout << number << " is " << result << std::endl;

    // 嵌套三元运算符
    int a = 15;
    std::string category = (a < 10) ? "Small"
                         : (a < 20) ? "Medium"
                         : "Large";
    std::cout << "Category: " << category << std::endl;

    // 三元运算符与函数调用
    int abs_value = (x < 0) ? -x : x;
    std::cout << "Absolute value of x: " << abs_value << std::endl;

    // 三元运算符在输出中的使用
    std::cout << "Is x greater than y? "
              << ((x > y) ? "Yes" : "No") << std::endl;

    return 0;
}

编译并运行程序：

g++ ternary_operator.cpp -o ternary_operator
./ternary_operator

示例输出：

Larger value: 10
7 is Odd
Category: Medium
Absolute value of x: 10
Is x greater than y? Yes

三元运算符的关键点：

• 语法： condition ? value_if_true : value_if_false。这是一种在一行中编写 if-else 语句的简写方式。
• 评估 condition。如果为真，则表达式返回 value_if_true；否则返回 value_if_false。
• 在代码中，int max_value = (x > y) ? x : y; 确定 x 和 y 中较大的数字。如果 x 大于 y，则将 x 赋值给 max_value，否则将 y 赋值给 max_value。因为 x 是 10，y 是 5，所以 max_value 变为 10。
• 表达式 std::string result = (number % 2 == 0) ? "Even" : "Odd"; 使用取模运算符 % 检查数字是偶数还是奇数。结果根据检查结果返回 "Even" 或 "Odd"，并将其赋值给字符串变量 result。
• 三元运算符可以嵌套，但这样做会很快使代码难以阅读。在示例中，嵌套三元运算符根据整数 a 的值将字符串 "Small"、"Medium" 或 "Large" 赋值给变量 category。
• 示例 int abs_value = (x < 0) ? -x : x; 展示了如何使用三元运算符获取 x 的绝对值。如果 x 为负数，则将其取反，相当于转换为绝对值。否则直接返回 x。
• 最后一个示例展示了如何直接打印三元运算符的结果：std::cout << "Is x greater than y? " << ((x > y) ? "Yes" : "No") << std::endl;

重要注意事项：

• 适度使用以保持代码的可读性。过度使用三元运算符，尤其是嵌套的三元运算符，会使代码难以理解。
• 如果过于复杂，可能会变得难以阅读。复杂的决策通常应使用完整的 if-else 块来表达。
• 主要用于简单、直接的条件，其中需要返回或赋值两个值之一。

总结

在本实验中，你学习了如何在 C++ 中执行基本的数学运算，包括加法、减法、乘法、除法和取模运算。你还探索了前置和后置递增/递减运算符的使用，理解了它们之间的细微差别。此外，你学习了关系运算符和逻辑运算符，以有效地比较和组合值。你还练习了位运算以进行二进制操作，以及复合赋值运算符以简化和压缩算术运算与赋值操作。最后，你理解了多运算符的运算顺序，并使用三元条件运算符编写简洁的条件语句。这些基本概念对于构建健壮且高效的 C++ 程序至关重要。通过掌握这些基本运算符，你将能够更好地应对更复杂的编码挑战。