Initial commit: C++ courseware
This commit is contained in:
xiaolinquan committed
commit
4a4ee7c287
1789 files changed
+373489
No files matched your search
Binary file not shown.
Binary file not shown.
+214
@@ -0,0 +1,214 @@
|
||||
# **算术运算符与关系运算符**
|
||||
|
||||
#### 1. 引言
|
||||
|
||||
* **问题引入**：想象一下，你要编写一个游戏。角色的生命值被敌人攻击后会减少，捡到血包后会增加；你的得分会随着击败敌人而累加。这些“增加”、“减少”、“累加”的操作，在代码中如何实现呢？答案就是使用算术运算符。
|
||||
* **价值阐述**：算术运算符是编程的基石。无论是简单的数值计算、复杂的科学模拟，还是游戏开发中的逻辑处理，都离不开它们。掌握好算有运算符，是写出任何有意义程序的先决条件。
|
||||
|
||||
#### 2. 核心思想
|
||||
|
||||
* **思路铺垫**：我们从小学就开始学习数学中的“加减乘除”，C++ 中的算术运算符和它们的思想是完全一样的。它们接收一个或两个数值，然后给出一个计算结果。
|
||||
|
||||
* **算法精讲**：
|
||||
* **基本运算符**：`+`, `-`, `*`, `/`, `%` 这五个是我们最熟悉的。
|
||||
* `+` (加法): `5 + 2` 结果是 `7`
|
||||
* `-` (减法): `5 - 2` 结果是 `3`
|
||||
* `*` (乘法): `5 * 2` 结果是 `10`
|
||||
* `/` (除法): `5 / 2` 结果是 `2` (注意：整数除法会舍弃小数部分)
|
||||
* `%` (取模/取余): `5 % 2` 结果是 `1` (计算 `5` 除以 `2` 的余数)
|
||||
* **自增/自减运算符**：在编程中，"让一个变量加 1" 这个操作极其频繁。每次都写 `a = a + 1;` 会有点繁琐。于是，C++ 提供了一个更简洁、更高效的写法：`++` 和 `--`。
|
||||
* `++` (自增): 让变量的值加 1。`a++` 或 `++a` 都等价于 `a = a + 1`。
|
||||
* `--` (自减): 让变量的值减 1。`a--` 或 `--a` 都等价于 `a = a - 1`。
|
||||
|
||||
* **步骤拆解 (前置与后置的关键区别)**
|
||||
这是一个非常重要的知识点，也是初学者的一个难点。让我们把它拆解清楚：
|
||||
|
||||
* **前置**: `++a` 或 `--a`
|
||||
|
||||
1. **第一步：先**让变量 `a` 的值改变（加 1 或减 1）。
|
||||
2. **第二步：再**把 `a` **改变后**的新值，用于整个表达式的计算。
|
||||
* **口诀：先变，再用。**
|
||||
|
||||
* **后置**: `a++` 或 `a--`
|
||||
|
||||
1. **第一步：先**使用变量 `a` **原始的、未改变的**值，用于整个表达式的计算。
|
||||
2. **第二步：再**让变量 `a` 的值改变（加 1 或减 1）。
|
||||
* **口诀：先用，再变。**
|
||||
|
||||
#### 3. 实例
|
||||
|
||||
* **具体案例**：我们通过两个简单的 `cout` 输出来看看前置和后置的差别。
|
||||
|
||||
* **分步演示 1：前置 `++x`**
|
||||
```cpp
|
||||
int x = 5;
|
||||
cout << ++x << endl; // 我们想知道这里会输出什么
|
||||
```
|
||||
**计算机的执行过程**：
|
||||
1. 遇到 `++x`，这是一个前置自增。
|
||||
2. **第一步 (先变)**：`x` 的值从 `5` 变为 `6`。
|
||||
3. **第二步 (再用)**：使用 `x` 改变后的新值 `6` 来执行 `cout` 输出。
|
||||
4. **最终结果**：屏幕上输出 `6`。
|
||||
|
||||
**分步演示 2：后置 `y++`**
|
||||
|
||||
```cpp
|
||||
int y = 5;
|
||||
cout << y++ << endl; // 这里又会输出什么？
|
||||
cout << y << endl; // 这一行又输出什么？
|
||||
```
|
||||
**计算机的执行过程**：
|
||||
|
||||
1. 遇到 `y++`，这是一个后置自增。
|
||||
2. **第一步 (先用)**：使用 `y` **原始的值 `5`** 来执行 `cout` 输出。所以第一行会输出 `5`。
|
||||
3. **第二步 (再变)**：在第一行 `cout` 语句**执行完毕后**，`y` 的值从 `5` 变为 `6`。
|
||||
4. 执行第二行 `cout << y;` 时，`y` 的值已经是 `6` 了。
|
||||
5. **最终结果**：屏幕上第一行输出 `5`，第二行输出 `6`。
|
||||
|
||||
* **复合赋值运算符**
|
||||
还有一些方便的简写形式，它们将算术运算和赋值结合起来，以下的例子中 `a` 与 `b` 均为整型变量：
|
||||
|
||||
* `a += b;` 等价于 `a = a + b;`
|
||||
* `a -= b;` 等价于 `a = a - b;`
|
||||
* `a *= b;` 等价于 `a = a * b;`
|
||||
* `a /= b;` 等价于 `a = a / b;`
|
||||
* `a %= b;` 等价于 `a = a % b;`
|
||||
|
||||
---
|
||||
|
||||
### **第二部分：关系运算符**
|
||||
|
||||
* **问题引入**：假设你要编写一个程序，判断一个学生的分数是否及格（大于等于60分）。或者，在一个游戏中，判断玩家的生命值是否已经降到了0。这些“是否大于等于”、“是否等于”的操作，单纯用算术运算符是无法完成的。我们需要新的工具来让程序进行**比较**和**判断**。
|
||||
|
||||
* **价值阐述**：如果说算术运算符让程序有了计算能力，那么关系运算符则赋予了程序**决策能力**。它是构建所有复杂逻辑（如 `if` 语句、循环）的基础。没有关系运算，程序就只是一台高级计算器，无法根据不同的情况做出不同的反应。
|
||||
|
||||
* **学习目标**：
|
||||
1. 理解并掌握 `bool` (布尔) 类型，知道它只有 `true` 和 `false` 两个值。
|
||||
2. 熟练使用 C++ 的 6 个关系运算符：`==`, `!=`, `>`, `<`, `>=`, `<=`。
|
||||
3. 理解关系运算符的运算结果是一个 `bool` 值。
|
||||
4. 掌握算术运算符和关系运算符混合使用时的**优先级**规则。
|
||||
|
||||
#### 2. 核心思想
|
||||
|
||||
* **思路铺垫：认识一个新的数据类型 `bool` 类型**
|
||||
在学习比较之前，我们得先知道比较的结果是什么。生活中的比较，结果通常是“是”或“否”。
|
||||
|
||||
* “你的年龄大于18岁吗？” -> “是” 或 “否”
|
||||
* “今天下雨了吗？” -> “是” 或 “否”
|
||||
在 C++ 中，我们用一种专门的类型来存储这种“是/否”、“真/假”的值，它就是 `bool` (布尔) 类型。
|
||||
* `true` (真): 代表“是”、“成立”。在计算机内部，通常用 `1` 来表示。
|
||||
* `false` (假): 代表“否”、“不成立”。在计算机内部，通常用 `0` 来表示。
|
||||
|
||||
```cpp
|
||||
bool isAdult = true; // 定义了一个 bool 类型的变量 isAdult 的值是 true
|
||||
bool isRaining = false; // 定义了一个 bool 类型的变量 isRaining 的值是 false
|
||||
```
|
||||
|
||||
* **关系运算符的种类**
|
||||
关系运算符就是用来比较两个值，其实很多关系与数学上是相同的。
|
||||
|
||||
| 运算符 | 名称 | 含义 | 例子 (a=5, b=10) | 结果 |
|
||||
| :----- | :------- | :------------------------- | :--------------- | :------ |
|
||||
| `==` | 等于 | 判断两边的值**是否相等** | `a == 5` | `true` |
|
||||
| `!=` | 不等于 | 判断两边的值是否不相等 | `a != b` | `true` |
|
||||
| `>` | 大于 | 判断左边的值是否大于右边 | `a > b` | `false` |
|
||||
| `<` | 小于 | 判断左边的值是否小于右边 | `a < b` | `true` |
|
||||
| `>=` | 大于等于 | 判断左值是否大于或等于右值 | `a >= 5` | `true` |
|
||||
| `<=` | 小于等于 | 判断左值是否小于或等于右值 | `b <= a` | `false` |
|
||||
|
||||
* **运算符优先级**
|
||||
当一个表达式里既有算术运算符又有关系运算符时，谁先算？比如 `3 + 4 > 2 * 3`。
|
||||
规则很简单：**先算术，后关系**。
|
||||
1. **最高级**：括号 `()`，永远最先计算。
|
||||
2. **第二级**：乘、除、取余 `*`, `/`, `%`。
|
||||
3. **第三级**：加、减 `+`, `-`。
|
||||
4. **第四级**：大小关系 `>`, `<`, `>=`, `<=`。
|
||||
5. **第五级**：相等关系 `==`, `!=`。
|
||||
|
||||
#### 3. 实例
|
||||
|
||||
* **具体案例**：分析表达式 `3 + 4 > 2 * 3` 的计算过程。
|
||||
|
||||
* **分步**：
|
||||
1. **扫描表达式**：`3 + 4 > 2 * 3`
|
||||
2. **应用优先级规则**：`*` 的优先级高于 `+` 和 `>`。
|
||||
* **计算 `2 * 3`**，得到 `6`。表达式变为 `3 + 4 > 6`。
|
||||
3. **再次扫描表达式**：`3 + 4 > 6`
|
||||
4. **应用优先级规则**：`+` 的优先级高于 `>`。
|
||||
* **计算 `3 + 4`**，得到 `7`。表达式变为 `7 > 6`。
|
||||
5. **最后一步**：执行关系运算 `7 > 6`。这个比较是成立的，所以结果是 `true`。
|
||||
|
||||
* 而在 `cout` 中直接输出 `bool` 值时，`true` 会显示为 `1`，`false` 会显示为 `0`。所以 `cout << (3 + 4 > 2 * 3);` 会输出 `1`。
|
||||
|
||||
#### 4. 代码实现
|
||||
|
||||
* **问题**：(书本 P33 例 3-1) 输入两个整数 `a` 和 `b`，判断并输出：
|
||||
1. `a` 是否大于 `b`？
|
||||
2. `a` 是否小于或等于 `b`？
|
||||
3. `a` 是否不等于 `b`？
|
||||
输出 3 个整数（1 代表真，0 代表假），用空格隔开。
|
||||
|
||||
* **完整代码**：
|
||||
```cpp
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
|
||||
int main() {
|
||||
// 定义需要输入的两个整型变量
|
||||
int a, b;
|
||||
|
||||
// 从键盘读取 a 和 b 的值
|
||||
cin >> a >> b;
|
||||
|
||||
// 计算第一个关系表达式 (a > b) 的结果并输出, a > b 的结果是一个 bool 值 (true 或 false)
|
||||
// cout 会自动将 true 转为 1, false 转为 0
|
||||
cout << (a > b) << " ";
|
||||
|
||||
// 计算第二个关系表达式 (a <= b) 的结果并输出
|
||||
cout << (a <= b) << " ";
|
||||
|
||||
// 计算第三个关系表达式 (a != b) 的结果并输出
|
||||
cout << (a != b) << endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
* **代码解读**：
|
||||
* `cin >> a >> b;`: 等待用户输入两个整数，分别存入变量 `a` 和 `b`。
|
||||
* `cout << (a > b) << " ";`: 这一行是核心。
|
||||
* ` (a > b)`: 括号不是必须的，但加上能让代码更清晰。计算机会先执行括号里的 `a > b`。
|
||||
* 假如输入 `10 5`，则 `10 > 5` 结果为 `true`。
|
||||
* `cout << true;`: `cout` 会将 `true` 以整数 `1` 的形式打印到屏幕上。
|
||||
* `<< " ";`: 紧接着输出一个空格，用于分隔结果。
|
||||
* 其他两行 `cout` 的逻辑完全相同。
|
||||
|
||||
#### 5. 验证与深化
|
||||
|
||||
* **常见问题 **
|
||||
1. **最大的陷阱：`==` 和 `=` 的区别是什么？**
|
||||
* `==` (两个等号) 是**关系运算符**，用来**判断**左右两边是否相等。它返回一个 `bool` 值。例如 `if (a == 5)` 是在问“a 等于 5 吗？”。
|
||||
* `=` (一个等号) 是**赋值运算符**，用来把右边的值**赋给**左边的变量。例如 `a = 5;` 是在命令“让 a 的值变成 5”。
|
||||
* **最常犯的错误**就是在需要判断的地方写了赋值，例如 ` a = 5`，这会导致逻辑错误且很难发现！**请务必牢记！**
|
||||
|
||||
2. **`y++` 所在的这行代码结束后，`y` 的值到底变了没有？**
|
||||
* **绝对变了！** 后置运算符的“后”指的是在“使用”之后，但在整个语句结束之前，变量的值就已经更新了。只要记住口诀“先用旧值，再变新值”就不会错。
|
||||
|
||||
3. **任何数字都能转成 `bool` 类型吗？**
|
||||
* 是的。C++ 有一个规则：**非零即为真**。
|
||||
* 当一个整数或浮点数转换为 `bool` 类型时，只要它的值**不是 `0`**，就转为 `true`。只有 `0` 会转为 `false`。
|
||||
* 例如：`(bool) -3` 的结果是 `true`，`(bool) 100` 的结果是 `true`，而 `(bool) 0` 的结果是 `false`。
|
||||
|
||||
---
|
||||
|
||||
#### 6. 总结与练习
|
||||
|
||||
* **要点回顾**
|
||||
1. **算术运算符**：`+`, `-`, `*`, `/` (整除), `%` (取余)。
|
||||
2. **自增/自减**：`++` 和 `--` 是 `+1` 和 `-1` 的简写。
|
||||
3. **前置 vs 后置**：`++a` (先变后用)，`a++` (先用后变)。
|
||||
4. **`bool` 类型**：专门存储 `true` (1) 和 `false` (0) 的类型，是判断的基础。
|
||||
5. **关系运算符**：`==`, `!=`, `>`, `<`, `>=`, `<=`，它们的结果都是 `bool` 类型。
|
||||
6. **优先级**：先算术，后关系。括号优先级最高。
|
||||
* **拓展思考**
|
||||
我们已经学会了如何进行一次比较，比如 `a > b`。但如果我想判断“一个数 `x` 是否既大于 0 又小于 10”呢？这需要**两个**关系运算同时成立。要连接多个关系表达式，我们就需要学习下一讲的内容——**逻辑运算符** (`&&`, `||`, `!`)。它们是构建更复杂判断逻辑的桥梁。
|
||||
BIN
Binary file not shown.
@@ -0,0 +1,158 @@
|
||||
# 逻辑运算符
|
||||
|
||||
### 1. 引言
|
||||
|
||||
* **问题引入**：
|
||||
妈妈许诺说：“如果你这次数学考到90分，**并且**英语也考到90分，我就给你买新的游戏机！”
|
||||
这里的关键是“**并且**”，它意味着两个条件必须**同时**满足。
|
||||
后来妈妈看你压力太大了，又说：好吧，要求降低一点。只要你数学考到90分，**或者**英语考到90分，我就带你去吃大餐！
|
||||
这里的关键是“**或者**”，它意味着两个条件只要满足**任意一个**就行。
|
||||
在C++中，我们如何表达这种“并且”、“或者”的复杂逻辑呢？
|
||||
|
||||
* **价值阐述**：逻辑运算符是构建程序决策的核心。它让我们可以将简单的判断 (`a > b`, `c == 0`) 组合成复杂的逻辑规则。从网站的用户登录（用户名**和**密码都正确）、游戏胜利条件（敌人数量为0**或**到达终点）、到复杂的AI决策，逻辑运算符无处不在。
|
||||
|
||||
* **学习目标**：
|
||||
1. 掌握 C++ 的三个逻辑运算符：`&&` (与), `||` (或), `!` (非)。
|
||||
2. 理解并能口述每个运算符的运算规则。
|
||||
3. 掌握“短路求值”这一重要特性，并理解其意义。
|
||||
4. 了解逻辑运算符、关系运算符和算术运算符之间的优先级关系。
|
||||
|
||||
### 2. 核心思想
|
||||
|
||||
* **思路铺垫**：
|
||||
我们已经知道，关系运算符（如 `>`、`==`）的运算结果是一个 `bool` 值（`true` 或 `false`）。逻辑运算符不做数值计算，它的工作对象就是这些 `bool` 值。它根据输入的 `true` 或 `false`，给出一个最终的 `true` 或 `false` 结果。
|
||||
|
||||
* **算法精讲**：
|
||||
C++ 主要有三个逻辑运算符，我们用来一一拆解。
|
||||
1. **逻辑与 `&&` (AND)**
|
||||
* **含义**：表示“并且”，要求左右两边的条件**都**为 `true` 时，最终结果才是 `true`。只要有一个是 `false`，结果就是 `false`。
|
||||
* **生活实例**：`数学 >= 90 && 英语 >= 90`。
|
||||
* **规则表 (真值表)**：
|
||||
| A | B | A && B |
|
||||
| :---: | :---: | :----: |
|
||||
| `true` | `true` | `true` |
|
||||
| `true` | `false`| `false`|
|
||||
| `false`| `true` | `false`|
|
||||
| `false`| `false`| `false`|
|
||||
* **记忆口诀**：**全真才为真，一假即为假。**
|
||||
|
||||
2. **逻辑或 `||` (OR)**
|
||||
含义**：表示“或者”，只要左右两边的条件有**任意一个**为 `true`，最终结果就是 `true`。只有当两个都为 `false` 时，结果才是 `false`。
|
||||
生活实例**：`数学 >= 90 || 英语 >= 90`。
|
||||
**规则表 (真值表)**：
|
||||
| A | B | A \|\| B |
|
||||
| :---: | :---: | :----: |
|
||||
| `true` | `true` | `true` |
|
||||
| `true` | `false`| `true` |
|
||||
| `false`| `true` | `true` |
|
||||
| `false`| `false`| `false`|
|
||||
* **记忆口诀**：**一真即为真，全假才为假。**
|
||||
|
||||
3. **逻辑非 `!` (NOT)**
|
||||
|
||||
**含义**：表示“取反”，它是一个单目运算符（只有一个操作数）。它会把 `true` 变成 `false`，把 `false` 变成 `true`。
|
||||
|
||||
**生活实例**：妈妈说：“只要你数学**不**低于70分就有奖励”。“不低于70分”等价于 `!(数学 < 70)`。
|
||||
|
||||
**规则表 (真值表)**：
|
||||
| A | !A |
|
||||
| :---: | :----: |
|
||||
| `true` | `false`|
|
||||
| `false`| `true` |
|
||||
* **记忆口诀**：**真变假，假变真。**
|
||||
|
||||
* **步骤拆解 (特性：短路求值)**
|
||||
计算机其实很聪明，它会用最快的方式得到逻辑运算的结果。
|
||||
|
||||
* **对于 `&&` (与)**：`条件A && 条件B`
|
||||
1. 计算机先计算 `条件A`。
|
||||
2. 如果 `条件A` 的结果是 `false`，它会想：“根据‘一假即为假’的规则，无论 `条件B` 是什么，最终结果肯定是 `false` 了。”
|
||||
3. 于是，计算机**直接返回 `false`，根本不会去计算 `条件B`**。这个行为就叫“短路”。
|
||||
* **回到例子**：如果你的数学考了88分 (`math >= 90` 为 `false`)，计算机根本不需要再看你的英语成绩，就知道你拿不到游戏机了。
|
||||
|
||||
* **对于 `||` (或)**：`条件A || 条件B`
|
||||
|
||||
1. 计算机先计算 `条件A`。
|
||||
2. 如果 `条件A` 的结果是 `true`，它会想：“根据‘一真即为真’的规则，无论 `条件B` 是什么，最终结果肯定是 `true` 了。”
|
||||
3. 于是，计算机**直接返回 `true`，根本不会去计算 `条件B`**。
|
||||
* **回到例子**：如果你的数学考了100分 (`math >= 90` 为 `true`)，计算机根本不需要再看你的英语成绩，就知道你已经有大餐吃了。
|
||||
|
||||
### 3. 实例
|
||||
|
||||
* **具体案例**：
|
||||
假设 `int score = 85;`，我们来分析表达式 `score > 80 && score < 90` 的真假。
|
||||
* **分步演示**：
|
||||
1. **拆分表达式**：这个逻辑表达式由两个关系表达式 `score > 80` 和 `score < 90`，以及一个逻辑运算符 `&&` 组成。
|
||||
2. **计算左侧**：`score > 80` -> `85 > 80` -> 结果为 `true`。
|
||||
3. **判断短路**：因为是 `&&` 运算，左侧为 `true` 还不能确定最终结果，所以**不能短路**，必须继续计算右侧。
|
||||
4. **计算右侧**：`score < 90` -> `85 < 90` -> 结果为 `true`。
|
||||
5. **最终结果**：`true && true` -> 根据 `&&` 的规则，最终结果为 `true`。
|
||||
|
||||
### 4. 代码实现
|
||||
|
||||
* **问题**：输入一个学生的数学和英语成绩，判断他是否能拿到游戏机（两门都>=90），是否能吃到大餐（任意一门>=90）。
|
||||
|
||||
* **完整代码**：
|
||||
```cpp
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
|
||||
int main() {
|
||||
int math_score, english_score;
|
||||
cout << "请输入数学成绩和英语成绩: ";
|
||||
cin >> math_score >> english_score;
|
||||
|
||||
// 判断是否能拿到游戏机 (&&)
|
||||
bool can_get_game = (math_score >= 90) && (english_score >= 90);
|
||||
|
||||
// 判断是否能吃到大餐 (||)
|
||||
bool can_get_dinner = (math_score >= 90) || (english_score >= 90);
|
||||
|
||||
// (了解即可)C++中，boolalpha 可以让我们直接输出 true 或 false 而不是被计算机转化的 0 和 1
|
||||
// 如果不添加下面这一行 cout << boolalpha; 那么输出 true 或 false 就会被计算机转为 1 和 0
|
||||
cout << boolalpha;
|
||||
|
||||
cout << "能拿到游戏机吗? " << can_get_game << endl;
|
||||
cout << "能吃到大餐吗? " << can_get_dinner << endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
* **代码解读**：
|
||||
* `bool can_get_game = (math_score >= 90) && (english_score >= 90);`
|
||||
* 我们把整个逻辑表达式的结果存入一个 `bool` 类型的变量 `can_get_game`。
|
||||
* 括号 `()` 的使用让代码的可读性变得非常好，我们一眼就能看出是在对两个条件进行 `&&` 操作。
|
||||
* `cout << boolalpha;`
|
||||
* 这是一个输出格式控制器。加上它之后，`cout` 在打印 `bool` 值时，会打印出 "true" 或 "false" ，而不是 "1" 或 "0"，这样结果更直观。
|
||||
|
||||
### 5. 深化
|
||||
* **运算符优先级**
|
||||
当一个复杂的表达式里什么运算符都有的时候，计算顺序是怎样的？
|
||||
**口诀：==非算关与或==** (`非` > `算术` > `关系` > `与` > `或`)
|
||||
|
||||
1. **最高**：`!` (逻辑非) 和 `()` (括号)
|
||||
2. **次高**：算术运算符 (`*`, `/`, `+`, `-`)
|
||||
3. **中等**：关系运算符 (`>`, `<`, `==`, `!=`)
|
||||
4. **次低**：`&&` (逻辑与)
|
||||
5. **最低**：`||` (逻辑或)
|
||||
|
||||
**黄金法则**：如果你不确定优先级，或者想让代码意图更清晰，**那就毫不犹豫地使用括号 `()`**！例如 `(a + b > 5) && (c == 0)`。
|
||||
|
||||
* **常见问题**：
|
||||
|
||||
1. **`0 || 0` 的结果是什么？**
|
||||
* 我们知道“非零即为真”，所以 `0` 在逻辑判断中被当作 `false`。
|
||||
* 表达式相当于 `false || false`。根据 `||` 的“全假才为假”规则，结果为 `false` (会输出 0)。
|
||||
2. `!(-3)` 的结果是什么？
|
||||
* `-3` 是一个非零数，所以它被当作 `true`。
|
||||
* 表达式相当于 `!(true)`。根据 `!` 的取反规则，结果为 `false` (会输出 0)。
|
||||
|
||||
### 6. 总结
|
||||
|
||||
* **要点回顾**：
|
||||
1. **逻辑与 `&&`**：全真才为真。左侧为假时发生短路。
|
||||
2. **逻辑或 `||`**：一真即为真。左侧为真时发生短路。
|
||||
3. **逻辑非 `!`**：取反，真变假，假变真。
|
||||
4. **优先级**：`!` > 算术 > 关系 > `&&` > `||`。**括号是王道**，**口诀：非算关与或**。
|
||||
5. **短路求值**：一种优化策略，可以避免不必要的计算。
|
||||
Binary file not shown.
+99
@@ -0,0 +1,99 @@
|
||||
### **C++ 逻辑表达式的构建 讲义**
|
||||
|
||||
#### **一、 目标**
|
||||
|
||||
我们的目标，是将生活中的复杂规则（自然语言）准确地翻译成计算机能懂的、没有歧义的逻辑表达式（代码）。
|
||||
|
||||
#### **二、 翻译的步骤公式**
|
||||
|
||||
无论规则多复杂，都可以遵循这三步：
|
||||
|
||||
1. **拆解**：将一句长长的规则，拆分成一个个最小的、不可再分的**独立判断条件**。
|
||||
* 例：“一个数字 `x` 是大于4的偶数” -> 拆成 `x > 4` 和 `x是偶数`。
|
||||
|
||||
2. **观察连接词**：找出连接这些独立条件的**逻辑关系词**。
|
||||
* “并且”、“同时”、“但” -> 对应 C++ 的 `&&`。**全真才为真，一假即为假。**
|
||||
* “或者”、“至少一个” -> 对应 C++ 的 `||`。**一真即为真，全假才为假。**
|
||||
* “不”、“不是” -> 对应 C++ 的 `!`，将一个条件的结果**取反**。
|
||||
|
||||
3. **组合**：用 C++ 的逻辑运算符将这些条件按顺序组合起来。
|
||||
|
||||
#### **三、 优先级**
|
||||
|
||||
计算机在计算表达式时，并不是简单地从左到右。也就是存在**运算符优先级**。**记忆口诀：非算关与或**
|
||||
|
||||
* **基本规则**：`!` (逻辑非) 的优先级最高，其次是 `&&` (逻辑与)，最后是 `||` (逻辑或)。
|
||||
* **使用括号 `()` 明确意图**
|
||||
* 为了避免优先级带来的混淆和错误，当一个表达式中同时包含多个逻辑运算符的时候时，**使用括号 `()` 来明确你的逻辑分组**，这既能保证程序正确，也让代码更容易阅读。
|
||||
* 例如：如果你数学**或者**英语考了100分，**并且**作业都写完了，我们就去游乐园。
|
||||
* 错误写法: `数学100分 || 英语100分 && 作业都写完了`（错误原因： `&&` 的优先级比 `||` 高）
|
||||
* 正确写法: `(数学100分 || 英语100分) && 作业都写完了`。
|
||||
|
||||
#### **四、 布尔变量**
|
||||
|
||||
以后当我们写条件表达式的时候，如果一个判断条件的结果，已经被保存在一个布尔（bool）变量里了，我们就可以直接根据它的语义来去使用。
|
||||
|
||||
假设我们已经将两个判断条件，分别存入了布尔变量 `a` 和 `b` 中：
|
||||
* `bool a = (考试成绩 > 80);` // a 代表“考试成绩大于80分”这件事
|
||||
* `bool b = (综合成绩 > 90);` // b 代表“综合成绩大于90分”这件事
|
||||
|
||||
当我需要写一个条件表达式来判断：“考试成绩大于80分 **并且** 综合成绩大于90分”时，我们就可以像翻译句子一样，把自然语言和我们的代码进行一一对照：
|
||||
|
||||
* “考试成绩大于80分” → 这正是我们的布尔变量 `a` 所代表的含义。
|
||||
* “并且” → 在代码中对应的就是逻辑运算符 `&&`。
|
||||
* “综合成绩大于90分” → 这正是我们的布尔变量 `b` 所代表的含义。
|
||||
|
||||
然后，把它们按顺序串联起来，就得到了最终的表达式：`a && b`。
|
||||
|
||||
这种方式让我们的代码逻辑和自然语言逻辑完全对应。而不需要通过 `a == true && b == true` 重复进行判断。
|
||||
|
||||
#### **五、 整除的逻辑表达式**
|
||||
|
||||
在编程中，我们经常需要判断一个数能否被另一个数整除。这在判断奇偶性、倍数关系时非常有用。
|
||||
|
||||
* **工具**：求余运算符 `%`。`a % b` 的意思是计算 `a` 除以 `b` 之后的**余数**。
|
||||
* **逻辑**：如果 `a` 能被 `b` 整除，那么 `a` 除以 `b` 之后**没有余数**，所以 **`a % b` 的结果就是 `0`**。
|
||||
* **实例**：
|
||||
* `9 % 3` 的结果是 `0`，所以 `9 % 3 == 0` 为 `true`，代表9是3的倍数。
|
||||
* `10 % 3` 的结果是 `1`，所以 `10 % 3 == 0` 为 `false`，代表10不能被3整除。
|
||||
|
||||
#### **六、 构建实例**
|
||||
|
||||
##### **实例1：闰年判断**
|
||||
|
||||
* **规则**：年份能被4整除**但**不能被100整除，**或者**能被400整除。
|
||||
* **第一步：拆解**
|
||||
* 条件A: 年份能被4整除 -> `year % 4 == 0`
|
||||
* 条件B: 年份不能被100整除 -> `year % 100 != 0`
|
||||
* 条件C: 年份能被400整除 -> `year % 400 == 0`
|
||||
* **第二步：观察连接词**
|
||||
|
||||
* 条件A和B之间是“但”（也就是“并且”）的关系。
|
||||
* (A和B的整体) 与 条件C之间是“或者”的关系。
|
||||
* **第三步：组合（使用括号明确优先级）**
|
||||
|
||||
```cpp
|
||||
bool a = ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0);
|
||||
```
|
||||
|
||||
##### **实例2：数字性质筛选**
|
||||
|
||||
* **规则**：一个数字 `x` 要满足“是3的倍数，但不是偶数”。
|
||||
* **第一步：拆解，并用布尔变量存起来**
|
||||
|
||||
* 条件A：“是3的倍数”
|
||||
```cpp
|
||||
bool b = (x % 3 == 0); // "是3的倍数" 的结果存在布尔变量 b 里
|
||||
```
|
||||
* 条件B：“是偶数”
|
||||
```cpp
|
||||
bool c = (x % 2 == 0); // "是偶数" 的结果存在布尔变量 c 里
|
||||
```
|
||||
* **第二步：观察连接词**
|
||||
* 条件A 和 “不是条件B” 之间是“但”（“并且”）的关系。
|
||||
* **第三步：组合（使用布尔变量）**
|
||||
|
||||
```cpp
|
||||
// 条件A和条件B的结果已经储存在布尔变量中了，可直接根据语义去使用。
|
||||
bool d = b && !c;
|
||||
```
|
||||
BIN
Binary file not shown.
+37
@@ -0,0 +1,37 @@
|
||||
### **C++ 算术与关系运算符 课后习题 - 答案**
|
||||
|
||||
#### **一、 填空题**
|
||||
|
||||
1. `/` , `%`
|
||||
2. `bool`
|
||||
3. 先变，再用
|
||||
4. 先用，再变
|
||||
5. `score = score - 10;`
|
||||
6. 乘法 (`*`) , 加法 (`+`) , 关系 (`>`)
|
||||
7. `==` , `=`
|
||||
|
||||
#### **二、 单项选择题**
|
||||
|
||||
1. **C**. 整数除法舍弃小数，`13 / 5` 的商是 `2`。
|
||||
2. **A**. `13` 除以 `5` 商 `2` 余 `3`。
|
||||
3. **B**. 前置自增，先将 `x` 变为 `11`，再输出新值 `11`。
|
||||
4. **A**. 后置自增，先输出 `x` 的原值 `10`，然后 `x` 的值才变为 `11`。
|
||||
5. **C**. 前置自减，`x` 先从 `5` 变为 `4`，然后将新值 `4` 赋给 `y`。
|
||||
6. **C**. 后置自减，先将 `x` 的原值 `5` 赋给 `y`，然后 `x` 自身的值从 `5` 变为 `4`。
|
||||
7. **C**. 先算术后关系。`5 + 2` 得 `7`，`8 - 4` 得 `4`。表达式变为 `7 > 4`，结果为 `true`，输出 `1`。
|
||||
8. **B**. `score /= 10;` 等价于 `score = score / 10;`，即 `100 / 10`，结果是 `10`。
|
||||
9. **C**. 不等于的关系运算符是 `!=`。
|
||||
10. **B**. `a++` 是后置自增，先用 `a` 的原值 `1` 参与运算，`1 + 2` 结果为 `3`。运算结束后，`a` 的值变为 `2`。
|
||||
|
||||
#### **三、 判断题**
|
||||
|
||||
1. √ (两个整数相除，结果只取整数部分。)
|
||||
2. √ (当不把它们作为表达式的一部分，而是独立作为一条语句时，两者都只是让变量自增1，效果相同。)
|
||||
3. × (根据讲义内容，`%` 主要用于整数运算。)
|
||||
4. × ( `==` 是判断相等，返回 `bool` 值； `=` 是赋值，改变变量的值。)
|
||||
5. × (这是后置 `++`，遵循“先用后变”原则，应是先把 `x` 的旧值赋给 `y`，然后 `x` 再加1。)
|
||||
6. √ (这是 `cout` 对于 `bool` 类型的默认输出规则。)
|
||||
7. √ (`10 >= 20` 这个关系不成立，结果是 `false`，输出为 `0`。)
|
||||
8. √ (讲义中明确指出“非零即为真”。)
|
||||
9. √ (括号用于强制改变运算优先级，是最高的。)
|
||||
10. √ ( `b = a++` 是后置运算，先将 `a` 的原值 `10` 赋给 `b`，然后 `a` 自身的值变为 `11`。 )
|
||||
+91
@@ -0,0 +1,91 @@
|
||||
### **C++ 算术与关系运算符 课后习题**
|
||||
|
||||
姓名: \_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_
|
||||
|
||||
#### **一、 填空题**
|
||||
|
||||
1. 两个整数相除，只会保留整数部分而舍弃小数的运算符是 \_\_\_\_\_\_\_\_\_\_；而计算整数除法余数的运算符是 \_\_\_\_\_\_\_\_\_\_。
|
||||
2. 在C++中，专门用来存储 `true` (真) 和 `false` (假) 这种值的类型是 \_\_\_\_\_\_\_\_\_\_ 类型。
|
||||
3. 前置自增 `++a` 的运算口诀是“\_\_\_\_\_\_\_\_\_\_，\_\_\_\_\_\_\_\_\_\_”，即先改变变量的值，再使用新值参与表达式运算。
|
||||
4. 后置自增 `a++` 的运算口诀是“\_\_\_\_\_\_\_\_\_\_，\_\_\_\_\_\_\_\_\_\_”，即先使用变量的旧值参与表达式运算，再改变变量的值。
|
||||
5. `score -= 10;` 这种写法叫做复合赋值，它和普通写法 \_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_ 是等价的。
|
||||
6. 在 `3 + 4 > 2 * 3` 这个表达式中，计算机会先计算 \_\_\_\_\_\_\_\_\_\_ 运算，再计算 \_\_\_\_\_\_\_\_\_\_ 运算，最后才进行 \_\_\_\_\_\_\_\_\_\_ 运算。
|
||||
7. 请务必区分：用于**判断**两个值是否相等的运算符是 \_\_\_\_\_\_\_\_\_\_，而用于**赋值**的运算符是 \_\_\_\_\_\_\_\_\_\_。
|
||||
|
||||
#### **二、 单项选择题**
|
||||
|
||||
( ) 1. 执行 `int a = 13, b = 5; cout << a / b;` 后，屏幕上会显示什么？
|
||||
A. 3   B. 2.6   C. 2   D. 8
|
||||
|
||||
( ) 2. 执行 `int a = 13, b = 5; cout << a % b;` 后，屏幕上会显示什么？
|
||||
A. 3   B. 2.6   C. 2   D. 0
|
||||
|
||||
( ) 3. 阅读以下代码，其输出结果是什么？
|
||||
```cpp
|
||||
int x = 10;
|
||||
cout << ++x;
|
||||
```
|
||||
A. 10   B. 11   C. 9   D. 无法确定
|
||||
|
||||
( ) 4. 阅读以下代码，其输出结果是什么？
|
||||
```cpp
|
||||
int x = 10;
|
||||
cout << x++;
|
||||
```
|
||||
A. 10   B. 11   C. 9   D. 无法确定
|
||||
|
||||
( ) 5. 阅读以下代码，执行后 `y` 的值是多少？
|
||||
```cpp
|
||||
int x = 5;
|
||||
int y = --x;
|
||||
```
|
||||
A. 5   B. 6   C. 4   D. 3
|
||||
|
||||
( ) 6. 阅读以下代码，执行完毕后 `x` 的值是多少？
|
||||
```cpp
|
||||
int x = 5;
|
||||
int y = x--;
|
||||
```
|
||||
A. 5   B. 6   C. 4   D. 3
|
||||
|
||||
( ) 7. `cout << (5 + 2 > 8 - 4);` 这行代码的输出结果是？
|
||||
A. true   B. false   C. 1   D. 0
|
||||
|
||||
( ) 8. `int score = 100; score /= 10;` 执行后，变量 `score` 的值是多少？
|
||||
A. 100   B. 10   C. 90   D. 110
|
||||
|
||||
( ) 9. “判断变量 `a` 的值是否不等于 `b`”，应该使用哪个表达式？
|
||||
A. `a =! b`   B. `a <> b`   C. `a != b`   D. `a = b`
|
||||
|
||||
( ) 10. `int a = 1, b = 2; cout << (a++ + b);` 这行代码的输出结果是？
|
||||
A. 2   B. 3   C. 4   D. 5
|
||||
|
||||
#### **三、 判断题 (对的打“√”，错的打“×”)**
|
||||
|
||||
1. `10 / 4` 在C++整型计算中的结果是 `2`。 ( )
|
||||
|
||||
2. `a++` 和 `++a` 作为独立的一行语句时，例如 `a++;` 和 `++a;`，它们的效果是完全一样的。 ( )
|
||||
|
||||
3. 取余（取模）运算符 `%` 可以用于 `double` 类型的变量。 ( )
|
||||
|
||||
4. 在C++中，关系运算符 `==` 和赋值运算符 `=` 的作用是相同的。 ( )
|
||||
|
||||
5. 在表达式 `int y = x++;` 中，是先把 `x` 的值加1，然后再把新值赋给 `y`。 ( )
|
||||
|
||||
6. 当 `cout` 一个 `bool` 类型的值时，`true` 会显示为 `1`，`false` 会显示为 `0`。 ( )
|
||||
|
||||
7. 以下代码执行后，会输出 `0`。 ( )
|
||||
```cpp
|
||||
int a = 10, b = 20;
|
||||
cout << (a >= b);
|
||||
```
|
||||
|
||||
8. 在C++中，只要一个数值不是 `0`，当它被用在逻辑判断中时，就会被当作 `true`。 ( )
|
||||
|
||||
9. 运算符 `()` 的优先级在所有运算符中是最高的。 ( )
|
||||
|
||||
10. 以下代码执行完毕后，变量 `a` 的最终值是 `11`。 ( )
|
||||
```cpp
|
||||
int a = 10;
|
||||
int b = a++;
|
||||
```
|
||||
BIN
Binary file not shown.
+37
@@ -0,0 +1,37 @@
|
||||
### **C++ 逻辑运算符 课后习题 - 答案**
|
||||
|
||||
#### **一、 填空题**
|
||||
|
||||
1. `&&` , `||` , `!`
|
||||
2. 全真才为真
|
||||
3. 一真即为真
|
||||
4. `false` , `true`
|
||||
5. 短路求值 (或 短路)
|
||||
6. `!` (非) , `&&` (与) , `||` (或)
|
||||
7. 算 关 与
|
||||
|
||||
#### **二、 单项选择题**
|
||||
|
||||
1. **D**. `(5 > 3)` 为 `true`，`(2 < 1)` 为 `false`。`true && false` 的结果是 `false`，输出为 `0`。
|
||||
2. **A**. `(10 == 9)` 为 `false`，`(3 != 4)` 为 `true`。`false || true` 的结果是 `true`，输出为 `1`。
|
||||
3. **B**. `-1` 是非零数，被视为 `true`。`!true` 的结果是 `false`，即 `0`。
|
||||
4. **C**. 题干描述了两个并列的条件，应该用 `||` 连接。“能被4整除但不能被100整除”是 `year % 4 == 0 && year % 100 != 0`，“能被400整除”是 `year % 400 == 0`。
|
||||
5. **B**. `a` 是 `1` (true)，`b` 是 `0` (false)。`true || false` 的结果是 `true`，输出为 `1`。
|
||||
6. **A**. 因为 `x > 1` (即 `5 > 1`) 的结果是 `true`，根据 `||` 的短路规则，后面的 `(y++ > 10)` 不会再执行，所以 `y` 的值保持 `10` 不变。
|
||||
7. **A**. 因为 `x > 1` (即 `0 > 1`) 的结果是 `false`，根据 `&&` 的短路规则，后面的 `(y++ > 10)` 不会再执行，所以 `y` 的值保持 `10` 不变。
|
||||
8. **D**. 一个数要么大于等于20，要么小于20，这两个条件覆盖了所有情况，所以用 `||` 连接起来结果永远为 `true`。
|
||||
9. **B**. `!` 优先级最高，`!true` 变为 `false`。表达式变为 `false || false && true`。`&&` 优先级高于 `||`，先算 `false && true` 结果为 `false`。最后表达式变为 `false || false`，结果为 `false`，即 `0`。
|
||||
10. **D**. `a > 1` (true) `&&` `a < 10` (false)，`true && false` 结果为 `false`。其他选项结果都为 `true`。
|
||||
|
||||
#### **三、 判断题**
|
||||
|
||||
1. √ ( `&&` 的优先级高于 `||`，就像乘法高于加法一样。)
|
||||
2. √ (当 `a` 为0时，`!a` 为 `true`，`a == 0` 也为 `true`。当 `a` 非0时，`!a` 为 `false`，`a == 0` 也为 `false`。)
|
||||
3. × (它会先算 `5 < x`，结果是 `true`(1) 或 `false`(0)，然后再拿这个 `1` 或 `0` 去和 `10` 比较，永远为 `true`。正确的写法是 `x > 5 && x < 10`。)
|
||||
4. × (关系运算符的优先级高于逻辑运算符。先判断大小关系，再进行逻辑组合。)
|
||||
5. × (这是 `||` 的短路特性，只要 `A` 为 `true`，整个表达式就确定为 `true`，无需再计算 `B`。)
|
||||
6. √ (`a > b` 即 `1 > 2` 为 `false`。`c > b` 即 `3 > 2` 为 `true`。`false || true` 结果为 `true`，输出 `1`。)
|
||||
7. × (`a` 是 `0`，即 `false`。对于 `&&` 运算，因为短路，`b++` 不会执行，`b` 的值仍然是 `10`。)
|
||||
8. √ (`0` 被视为 `false`，`!false` 的结果是 `true`，即 `1`。)
|
||||
9. √ (`true && false` 的结果是 `false`，`cout` 输出 `bool` 类型的 `false` 时会显示 `0`。)
|
||||
10. √ (这正是逻辑或 `||` 的定义。)
|
||||
BIN
Binary file not shown.
@@ -0,0 +1,81 @@
|
||||
### **C++ 逻辑运算符 课后习题**
|
||||
|
||||
姓名: \_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_
|
||||
|
||||
#### **一、 填空题**
|
||||
|
||||
1. C++ 中用来表示逻辑“与”的运算符是 \_\_\_\_\_\_\_\_\_\_，表示逻辑“或”的运算符是 \_\_\_\_\_\_\_\_\_\_，表示逻辑“非”的运算符是 \_\_\_\_\_\_\_\_\_\_。
|
||||
2. 逻辑与 `&&` 的运算规则是：两个条件必须都为 `true`，结果才为 `true`，这叫做“\_\_\_\_\_\_\_\_\_\_，一假即为假”。
|
||||
3. 逻辑或 `||` 的运算规则是：只要有一个条件为 `true`，结果就为 `true`，这叫做“\_\_\_\_\_\_\_\_\_\_，全假才为假”。
|
||||
4. 在C++的逻辑判断中，整数 `0` 会被当作 \_\_\_\_\_\_\_\_\_\_ 来看待，而任何非零的整数（如 `5`、`-10`）都会被当作 \_\_\_\_\_\_\_\_\_\_ 来看待。
|
||||
5. 在 `A && B` 这个表达式中，如果 `A` 的值为 `false`，程序就不会再去计算 `B` 的值，这种现象叫做 \_\_\_\_\_\_\_\_\_\_。
|
||||
6. 运算符的优先级决定了计算顺序，逻辑运算符的优先级从高到低是：\_\_\_\_\_\_\_\_\_\_ > \_\_\_\_\_\_\_\_\_\_ > \_\_\_\_\_\_\_\_\_\_。
|
||||
7. 运算符优先级顺序的口诀是：非 > \_\_\_\_\_\_ > \_\_\_\_\_\_ > \_\_\_\_\_\_ > 或。
|
||||
|
||||
#### **二、 单项选择题**
|
||||
|
||||
( ) 1. 执行 `cout << ((5 > 3) && (2 < 1));` 这行代码，屏幕上会输出什么？
|
||||
A. true   B. false   C. 1   D. 0
|
||||
|
||||
( ) 2. 执行 `cout << ((10 == 9) || (3 != 4));` 这行代码，屏幕上会输出什么？
|
||||
A. 1   B. 0   C. true   D. false
|
||||
|
||||
( ) 3. 表达式 `!(-1)` 的计算结果是什么？
|
||||
A. 1   B. 0   C. -1   D. 语法错误
|
||||
|
||||
( ) 4. “年份 `year` 是闰年”的条件是“能被4整除但不能被100整除，或者能被400整除”。下列哪个表达式是正确的？
|
||||
A. `year % 4 == 0 && year % 100 != 0 && year % 400 == 0`
|
||||
B. `year % 4 == 0 || year % 100 != 0 && year % 400 == 0`
|
||||
C. `(year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)`
|
||||
D. `year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)`
|
||||
|
||||
( ) 5. 阅读以下代码，其输出结果是什么？
|
||||
```cpp
|
||||
int a = 1, b = 0;
|
||||
cout << (a || b);
|
||||
```
|
||||
A. 0   B. 1   C. 2   D. a
|
||||
|
||||
( ) 6. 阅读以下代码，执行后变量 `y` 的值是多少？
|
||||
```cpp
|
||||
int x = 5, y = 10;
|
||||
bool result = (x > 1) || (y++ > 10);
|
||||
```
|
||||
A. 10   B. 11   C. 5   D. 1
|
||||
|
||||
( ) 7. 阅读以下代码，执行后变量 `y` 的值是多少？
|
||||
```cpp
|
||||
int x = 0, y = 10;
|
||||
bool result = (x > 1) && (y++ > 10);
|
||||
```
|
||||
A. 10   B. 11   C. 0   D. 1
|
||||
|
||||
( ) 8. 下列表达式中，结果一定是 `true` (或 `1`) 的是？（假设 `x` 为 `int` 类型变量）
|
||||
A. `x > 0 && x < 0`   B. `x > 100`   C. `!(x > 10)`   D. `x >= 20 || x < 20`
|
||||
|
||||
( ) 9. 根据运算符优先级，表达式 `!true || false && true` 的结果是？
|
||||
A. 1   B. 0   C. 无法计算   D. true
|
||||
|
||||
( ) 10. `int a = 10;`，下列哪个表达式的结果是 `false` (或 `0`) ？
|
||||
A. `a > 5`   B. `a > 5 || a < 1`   C. `! (a == 5)`   D. `a > 1 && a < 10`
|
||||
|
||||
#### **三、 判断题 (对的打“√”，错的打“×”)**
|
||||
|
||||
1. 逻辑运算符 `&&` 的优先级比 `||` 要高。 ( )
|
||||
2. 对于 `int` 型变量 `a`，表达式 `!a` 和 `a == 0` 在逻辑判断上是等价的。 ( )
|
||||
3. 在 C++ 中，`5 < x < 10` 这个表达式可以正确地判断 `x` 是否在 5 和 10 之间。 ( )
|
||||
4. 关系运算符（如 `>`、`==`）的优先级要低于逻辑运算符（如 `&&`）。 ( )
|
||||
5. 在表达式 `A || B` 中，如果 `A` 的计算结果为 `true`，那么计算机就必须再计算 `B` 的值才能确定最终结果。 ( )
|
||||
6. 以下代码执行后，会输出 `1`。 ( )
|
||||
```cpp
|
||||
int a = 1, b = 2, c = 3;
|
||||
cout << (a > b || c > b);
|
||||
```
|
||||
7. 以下代码执行后，变量 `b` 的值会变成 `11`。 ( )
|
||||
```cpp
|
||||
int a = 0, b = 10;
|
||||
bool result = a && (b++);
|
||||
```
|
||||
8. 表达式 `!0` 的计算结果是 `1`。 ( )
|
||||
9. `cout << (true && false);` 的输出结果是 `0`。 ( )
|
||||
10. 当我们想表达“两个条件中至少有一个满足”时，应该使用 `||` 运算符。 ( )
|
||||
BIN
Binary file not shown.
+28
@@ -0,0 +1,28 @@
|
||||
### **参考答案**
|
||||
|
||||
#### **一、 填空题**
|
||||
|
||||
1. `&&`， 括号 `()`
|
||||
2. `(x % 3 == 0) && (x % 2 != 0) && (x % 5 != 0)`
|
||||
3. `is_blue && price < 50`
|
||||
4. `(x >= 10 && x <= 20) || (x >= 30 && x <= 40)`
|
||||
5. `!is_ready`
|
||||
6. `((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)`
|
||||
7. `(A && B) || (A && C) || (B && C)`
|
||||
8. `false`
|
||||
9. `!(x == 10)`
|
||||
|
||||
#### **二、 单项选择题**
|
||||
|
||||
1. **B**. "等级和红宝石"是一个整体，"VIP和蓝宝石"是另一个整体，两者是“或者”关系。
|
||||
2. **B**. 因为 `chinese > 90` (88 > 90) 是 `false`，导致 `(math > 90 && chinese > 90)` 整体为 `false`。
|
||||
3. **C**. 选项A, B, D描述的都是“可以举办活动”的条件。选项C描述的是“**不能**举办活动”的条件，所以是错误的。
|
||||
4. **A**. `!(true && false)` -> `!false` -> `true`。 `(false || !true)` -> `(false || false)` -> `false`。最终 `true || false` -> `true`。
|
||||
5. **C**. "数学或者英语100分"是一个整体条件，需要用括号括起来，再与“作业写完”进行`&&`运算。
|
||||
7. **D**. 因为 `x > 5` (5 > 5) 是 `false`，导致整个`&&`表达式为`false`。其他选项均为`true`。
|
||||
8. **B**. “不大于10”就是“小于等于10”的意思。
|
||||
|
||||
#### **三、 构建逻辑表达式**
|
||||
|
||||
1. `login_ok || token_ok`
|
||||
2. `!is_special && (is_vip || amount > 200)`
|
||||
@@ -0,0 +1,80 @@
|
||||
### **C++ 逻辑运算符构建实例 **
|
||||
|
||||
姓名: \_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_
|
||||
|
||||
#### **一、 填空题**
|
||||
|
||||
1. 当一个判断条件里既有 `&&` 又有 `||` 时，计算机会先算 \_\_\_\_\_\_\_\_\_\_\_\_\_部分。如果我们想改变运算顺序，可以使用 \_\_\_\_\_\_\_\_\_\_\_\_\_改变运算优先级。
|
||||
|
||||
2. 一个数字 `x` 要满足“是3的倍数，但不是2的倍数，也不是5的倍数”，这个条件写成逻辑表达式为：\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_。
|
||||
|
||||
3. 小明想买一个玩具，条件是：玩具是蓝色的（结果储存在布尔变量`is_blue`中），并且价格（`price`）低于50元。这个购买条件可以写成表达式：\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_。
|
||||
|
||||
4. 判断一个数 `x` 是否在区间 `[10, 20]` 或者 `[30, 40]` （包括边界）内，表达式可以写成：\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_。
|
||||
|
||||
5. 如果布尔变量 `is_ready` 代表“准备就绪”，那么判断“**未**准备就绪”的最简洁表达式是 \_\_\_\_\_\_\_\_\_\_，而不是 `is_ready == false`。
|
||||
|
||||
6. 闰年的判断条件是：年份(`year`)能被4整除但不能被100整除，**或者**能被400整除。这个完整的表达式为: \_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_。
|
||||
|
||||
7. 如果 `A`, `B`, `C` 三个条件中**至少有两个**成立，那么表达式就可以写成：\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_。（提示：AB成立，或者AC成立，或者BC成立）
|
||||
|
||||
8. 已知 `bool a = true, b = false;`，那么表达式 `a && b` 的结果是 \_\_\_\_\_\_\_\_ (填`true`或`false`)。
|
||||
|
||||
9. 要判断“x不等于10”，我们可以写成 `x != 10`，也可以用逻辑非运算符写成 \_\_\_\_\_\_\_\_\_\_\_\_\_。
|
||||
|
||||
#### **二、 单项选择题**
|
||||
|
||||
( ) 1. 某游戏进入隐藏关卡的条件是：玩家等级（`level`）大于50 **并且** 拥有“红宝石”（`has_red_gem`），**或者** 玩家是VIP（`is_vip`）**并且** 拥有“蓝宝石”（`has_blue_gem`）。下面哪个表达式是正确的？
|
||||
A. `level > 50 && (has_red_gem || is_vip) && has_blue_gem`
|
||||
B. `(level > 50 && has_red_gem) || (is_vip && has_blue_gem)`
|
||||
C. `level > 50 || (has_red_gem && is_vip) || has_blue_gem`
|
||||
D. `level > 50 && has_red_gem && is_vip && has_blue_gem`
|
||||
|
||||
( ) 2. 学校评选“优秀少先队员”的条件是：数学成绩（`math`）和语文成绩（`chinese`）都在90分以上，并且品德成绩（`conduct`）不能低于85分。小明的成绩是 `math=95, chinese=88, conduct=90`。判断小明是否符合条件的表达式 `(math > 90 && chinese > 90) && conduct >= 85` 的结果是？
|
||||
A. true (1) B. false (0)
|
||||
|
||||
( ) 3. 一个机器人活动需要满足以下所有条件：天气晴朗（`is_sunny`），温度（`temp`）在15到25度之间，并且风力（`wind`）小于3级。下面哪个表达式是**错误**的？
|
||||
A. `is_sunny && (temp >= 15 && temp <= 25) && wind < 3`
|
||||
B. `is_sunny && temp >= 15 && temp <= 25 && wind < 3`
|
||||
C. `!is_sunny || temp < 15 || temp > 25 || wind >= 3`
|
||||
D. `is_sunny && temp >= 15 && !(temp > 25) && wind < 3`
|
||||
|
||||
( ) 4. 给定 `bool a = true; bool b = false; bool c = true;`，表达式 `!(a && b) || (b || !c)` 的结果是？
|
||||
A. true (1) B. false (0)
|
||||
|
||||
( ) 5. 小红的妈妈说：“如果你数学**或者**英语考了100分，**并且**作业都写完了，我们周末就去游乐园。” 假设 `math_ok` 代表数学100分，`eng_ok` 代表英语100分，`hw_done` 代表作业写完。下面哪个表达式正确地表达了去游乐园的条件？
|
||||
A. `math_ok || eng_ok && hw_done`
|
||||
B. `math_ok && eng_ok || hw_done`
|
||||
C. `(math_ok || eng_ok) && hw_done`
|
||||
D. `math_ok && (eng_ok || hw_done)`
|
||||
|
||||
( ) 6. 已知 `int x = 5, y = 10;`，下面哪个表达式的值是 `false`?
|
||||
A. `x < 10 && y > 5`
|
||||
B. `x == 5 || y == 5`
|
||||
C. `!(x > y)`
|
||||
D. `x > 5 && y == 10`
|
||||
|
||||
( ) 7. 表达式 `!(x > 10)` 和下面哪个表达式是等价的？
|
||||
A. `x < 10`
|
||||
B. `x <= 10`
|
||||
C. `x != 10`
|
||||
D. `x > 10`
|
||||
|
||||
#### **三、 构建逻辑表达式**
|
||||
|
||||
根据以下描述，使用给定的变量名写出对应的 C++ 逻辑表达式。
|
||||
|
||||
1. 一个账号可以登录，需要满足以下条件之一：
|
||||
* (1) 用户名和密码正确（结果储存在 `login_ok` 的布尔变量中）。
|
||||
|
||||
* (2) 用户通过了手机验证（结果储存在 `token_ok` 的布尔变量中）。
|
||||
|
||||
|
||||
**写出表达式：** \_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_。
|
||||
|
||||
2. 一个商品可以享受折扣，条件是：
|
||||
* 商品**不是**“特价商品” (`is_special` 为 `false`)
|
||||
* **并且** (顾客是VIP会员(`is_vip`) **或者** 消费金额(`amount`)大于200元)。
|
||||
* 提示：`is_special` 与 `is_vip` 都是布尔变量
|
||||
|
||||
**写出表达式：** \_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_。
|
||||
Binary file not shown.
Reference in new issue
Block a user