Initial commit: C++ courseware

2026-11-05 22:51:02 +08:00
commit 4a4ee7c287
@@ -0,0 +1,143 @@
+### **C++ 字符类型 `char` 与转义字符 讲义**
+
+#### **第一部分：字符类型 `char` (存储单个字符的盒子)**
+
+##### **1. 问题引入：除了数字，程序还能处理什么？**
+
+在之前的学习中，我们已经学会了用 `int` 存储整数，用 `double` 存储小数。但我们的世界是由丰富多彩的文字和符号构成的。比如，我们要编写一个程序，实现一个简易计算器，用户会输入 `7 * 2` 这样的算式。
+*   `7` 和 `2`，我们可以用 `int` 类型的变量来存储。
+*   但是中间的那个乘号 `*` 呢？它不是一个数字，我们该用什么类型的“盒子”来装它呢？
+
+这时候，`char` 类型就登场了。
+
+##### **2. 什么是 `char` 类型？**
+
+`char` 是 "character" (翻译：字符) 的缩写。它是一种专门用来存放**单个字符**的数据类型。
+你可以把它想象成键盘上的**任意一个按键**，它可以是：
+
+*   一个英文字母 (大写或小写): `'A'`, `'b'`, `'Z'`
+*   一个数字字符: `'0'`, `'1'`, `'9'`  (注意：这和数字 `0, 1, 9` 是不同的)
+*   一个标点或符号: `','`, `'.'`, `'?'`, `'+'`, `'*'`
+*   一个空格: `' '`
+
+##### **3. 如何在 C++ 中使用 `char`？**
+
+`char` 的使用方式和 `int` 基本一致，但有一个**极其重要**的区别：
+
+> **在为 `char` 变量赋值或进行比较时，字符值必须被一对单引号 `' '` 包围。**
+
+*   **正确的写法**:
+    ```cpp
+    char c1 = 'A'; // 正确！用单引号包围
+    char c2 = '*';
+    char c3 = ' '; // 空格也是一个字符
+    ```
+*   **错误的写法**:
+    ```cpp
+    char c4 = A;   // 错误！编译器会认为 A 是一个变量名，而不是字符'A'
+    char c5 = "A"; // 错误！双引号 "" 是用来表示字符串的，不能用于单个字符
+    ```
+
+##### **4. 实战演练：简易计算器**
+
+*   **问题**：输入两个整数和一个乘号 `*`，输出这两个整数的乘积。
+    
+    *   *输入样例*: `7 * 2`
+    *   *输出样例*: `14`
+*   **逻辑分析**：
+    
+    1.  **准备“盒子”**：我们需要两个盒子装整数，一个盒子装中间的 `*` 号。
+        *   `int num1, num2;`
+        *   `char op;`  (`op` 是 operator/操作符的英文缩写)
+    2.  **接收“原料”**：C++ 的 `cin` 非常智能，它会根据你变量的顺序和类型，自动读取并分割输入。
+        *   `cin >> num1 >> op >> num2;`  当用户输入 `7 * 2` 时，`cin` 会把 `7` 存入 `num1`，把 `*` 存入 `op`，把 `2` 存入 `num2`。
+    3.  **加工计算**：`int result = num1 * num2;`
+    4.  **交付产品**：`cout << result;`
+*   **完整代码**：
+    ```cpp
+    #include <iostream>
+    using namespace std;
+    
+    int main() {
+        int num1, num2;
+        char op; // 准备一个char类型的盒子来装运算符
+    
+        cout << "请输入一个乘法表达式 (如 7 * 2): ";
+        cin >> num1 >> op >> num2;
+    
+        int result = num1 * num2;
+        cout << "计算结果是: " << result << endl;
+        
+        return 0;
+    }
+    ```
+
+---
+
+#### **第二部分：转义字符**
+
+##### **1. 观察代码**
+
+我们已经知道，放在双引号 `""` 里的内容，通常会被原样输出。但请观察以下代码：
+```cpp
+cout << "hello\nworld"; 
+```
+按照我们的直觉，屏幕上应该会打印出 `hello\nworld`。但实际运行结果却是：
+```
+hello
+world
+```
+
+我们发现：
+1.  字符 `\` 和 `n` 在屏幕上“神秘地消失”了。
+2.  `world` 被打印到了新的一行。
+
+**原因解析**：这并不是 Bug，而是因为 `\n` 是 C++ 语法中的一个**转义字符。
+
+##### **2. 转义字符的原理与应用**
+
+*   **什么是转义字符？**
+    转义字符是一种特殊的符号组合，它以反斜杠 `\` 开头，用于在代码中表示一些**无法直接打印的控制功能**（如换行、制表符）或**具有特殊语法含义的字符本身**（如双引号、反斜杠自己）。
+
+    你可以把反斜杠 `\` 想象成一个“**魔法棒**”。当它出现在一个字符前面时，它会**改变**后面那个字符的本来面目，赋予它一个特殊的魔法效果。
+
+*   **常用转义字符对照表**
+    | 转义符   | 术语           | 实际作用与说明                                               |
+    | -------- | -------------- | ------------------------------------------------------------ |
+    | **`\n`** | **换行符**     | 效果：**换行**。将光标移动到下一行的行首。                   |
+    | **`\t`** | **水平制表符** | 效果：**对齐**。将光标向前跳跃一个制表位的距离（通常相当于几个空格）。 |
+    | **`\\`** | **反斜杠字符** | 效果：让它变回一个普通的反斜杠字符并打印出来，即输出一个反斜杠本身。 |
+    | **`\"`** | **双引号字符** | 效果：让它变回一个普通的双引号字符并打印出来，即输出一个双引号本身。 |
+    | **`\'`** | **单引号字符** | 用于打印单引号本身。                                         |
+
+##### **3. 综合应用实例**
+
+*   **任务目标**：在屏幕上输出下面这句话：
+    
+    > `小明说:"what is \n"`
+    
+*   **逻辑推演**：
+    
+    1.  **基础结构**：首先，整句话是一个字符串需要通过 `cout` 输出，那么需要用一对双引号包围。
+        `cout << "小明说:"what is \n"";`  <-- 如果这样直接写，就全部乱套了！
+    2.  **解决内部双引号冲突**：目标文本中的双引号 `"` 会让编译器误以为字符串提前结束了。我们需要用 `\"` 来告诉编译器：这个双引号只是一个普通字符，我想要输出它本身，不是字符串的边界。
+    3.  **解决 `\` 的冲突**：我们想输出 `\` 本身。于是我们需要用 `\\` 来打印出那个反斜杠本身。
+        `cout << "小明说:\"what is \\n\"";` <-- 解决！
+
+*   **C++ 实现代码**：
+    ```cpp
+    #include <iostream>
+    using namespace std;
+    
+    int main() {
+        cout << "小明说:\"what is \\n\"" << endl;
+        return 0;
+    }
+    ```
+
+#### **总结**
+
+*   **`char`** 是用来存储**单个**字符的“小盒子”，它的值必须用**单引号`''`**括起来。
+*   **转义字符**以反斜杠 `\` 开头，它能赋予紧随其后的字符一个**特殊的功能**或让其**变回普通字符**。
+*   `\n` (换行) 和 `\t` (制表) 是最常用的功能性转义字符。
+*   当你需要在字符串中打印 `"` 或 `\` 本身时，必须在它们前面再加上一个 `\`，即使用 `\"` 和 `\\`。
@@ -0,0 +1,142 @@
+# C++字符与 ASCII 码 讲义
+
+## 1. 概念
+
+在计算机的世界里，一切皆是 0 和 1（二进制）。计算机天生只认识数字，不认识字母、标点符号。
+为了让计算机能显示和处理文字，人类制定了一套规则：**给每一个字符指定一个唯一的数字编号**。
+
+*   **字符 (Character)**：我们在屏幕上看到的符号（如 `'A'`, `'@'`, `'1'`）。
+*   **ASCII 码**：一种最基础的编码标准，规定了字符和数字之间的对应关系。
+
+---
+
+## 2. C++ 中的字符类型 (`char`)
+
+在 C++ 中，我们学习了如何储存一个整数或者小数，但是字符是使用 `char` 关键字来定义并储存字符变量的。
+
+### 2.1 基本语法
+*   **书写方式**：必须使用**单引号** `' '` 括起来。
+*   **本质**：`char` 类型在内存中实际上存储的是一个**整数**（即该字符对应的 ASCII 码值）。
+
+```cpp
+char letter = 'A';  // 正确
+char numChar = '5'; // 正确，这是字符5，不是数字5
+// char error = "A"; // 错误！双引号代表字符串
+```
+
+### 2.2 使用 `char`
+
+**题目描述:请你实现普通计算器的功能，输入两个整数和一个*，输出这两个整数的乘积。**
+
+**样例输入: 7 * 2**
+
+**样例输出: 14**
+
+---
+
+**逻辑解析：**
+
+- **定义容器**：我们需要两个 `int` 类型的变量来存放参与运算的数字，**以及一个 `char` 类型的变量来存放中间的运算符 `*`**，我们就可以定义：`int num1, num2;  char ch; `
+
+- **获取数据**：接受用户输入，将三个值分别放入三个变量中，并且按照顺序读取 `cin >> num1 >> ch >> num2;` 
+
+  - **读取 `num1`**：读取的第一个是整数变量，于是`cin` 接着期待一个整数，例如它读取了 `7`，接着遇到了空格。所以它会**自动结束读取**，将 `7` 存入 `num1` 中。
+
+  - **读取 `op`**：接着是一个字符类型变量，于是`cin` 接着期待一个字符。拿到了字符 `*`，并存入字符变量 `op` 中。
+
+  - **读取 `num2`**：最后，`cin` 再次期待一个整数。它跳过空格，读取到数字 `2`，存入 `num2`。
+
+- **计算结果：**`num1`  与 `num2` 已经存入了输入的两个整数，最后仅需按照题目要求输出这两个整数的乘积即可：`cout << num1 * num2;`
+
+## 3. 什么是 ASCII 码？
+
+**全称**：American Standard Code for Information Interchange（美国信息交换标准代码）。
+
+因为计算机却只认识数字，不认识字符，那计算机怎么存储“Hello”这个单词呢？
+
+为了解决这个问题，人类制定了一张**强制转换表**，这就是 **ASCII** **码表**。 它规定了每一个符号对应一个特定的整数。字符在计算机内部，本质上就是一个整数。
+
+它是一张“对照表”，规定了 128 个字符对应的数字。
+
+- 当你按下键盘上的 `A`。
+- 计算机查表：哦，`A` 对应的是 `65`。
+- 计算机存储：在内存里存下 `65` 。
+- 当你 `cout` 时：计算机读取 `65`，查表发现是 `A`，然后就输出一个 `A` 在屏幕上
+
+### 3.1 ASCII 码表的构成
+1.  **0 - 31 (控制字符)**：不可打印，用于控制外围设备，这部分**了解**即可，一般不会用到。
+    *   例如在我们键盘上的：换行、回车、响铃、退格。
+2.  **32 - 126 (可打印字符)**：键盘上能打出来的符号。
+    *   包括：空格、标点、数字、大写字母、小写字母。**这部分需要知道掌握**。
+3.  **127 (Delete)**：删除控制符，**了解**即可。
+
+---
+
+## 4. 必须记住的关键 ASCII 值
+
+你不需要背诵整个表，但以下几个数值应当记住，因为它们常用于编程逻辑中。
+
+| 字符类别     | 起始字符 | ASCII 值 | 结束字符 | ASCII 值 | 备注                              |
+| :----------- | :------: | :------: | :------: | :------: | :-------------------------------- |
+| **数字**     |  `'0'`   |  **48**  |  `'9'`   |  **57**  | 注意：`'0'` 和 `0` 不是同一个东西 |
+| **大写字母** |  `'A'`   |  **65**  |  `'Z'`   |  **90**  |                                   |
+| **小写字母** |  `'a'`   |  **97**  |  `'z'`   | **122**  |                                   |
+
+### 规律总结：
+1.  数字、大写字母、小写字母都是**连续**排列的。
+2.  **大小写转换规律**：小写字母的 ASCII 值比对应的大写字母大 **32**。
+    *   `'a' - 'A' = 32`
+    *   `'A' + 32 = 'a'`
+
+---
+
+## 5. 字符与整数的互换 (C++ 的自动类型转换特性)
+
+在 C++ 中，其实`char` 和 `int` 可以自由转换和运算。
+
+1. 源类型向目标类型转换时。如果目标类型能够容纳源类型的值，且转换是安全的，编译器就会自动完成。
+   - **例如**：`int` 赋给 `double` 是安全的（`int` 转换为 `double`）。
+   - **但请注意：** `double` 赋给 `int` 时，虽然编译器会尝试转换（截断小数部分），但这通常被认为是**不安全的**，因为它会丢失精度。在严格的编译环境下可能会有警告，甚至在某些情况下需要显式转换（后续会讲解强制类型转化）。
+   - **整型和浮点型混合运算时，整型会向浮点型转换以避免数据丢失**。**核心原则是** “向高精度、大范围类型转换”，以避免数据丢失。例如，`int` 和 `double` 相加时，`int` 会被转换为 `double`。
+
+简单来说，C++的自动类型转换是尽力让你在不同类型之间进行操作时，得到一个合理的结果，并且尽量不丢失数据。
+
+### 5.1 查看字符的 ASCII 码
+**使用 `int` 类型的变量来接住 `char` 类型的值。**
+
+```cpp
+#include <iostream>
+using namespace std;
+
+int main() {
+    char c = 'A';
+    cout << "字符: " << c << endl;          // 输出 A
+    int num = c;
+    cout << "ASCII值: " << num << endl; // 输出 65
+    return 0;
+}
+```
+
+### 5.2 字符运算 (算术操作)
+**因为字符本质是整数（通过ASCII码来进行对照），所以可以进行加减乘除。**
+
+==**案例 1：大小写转换(重要，必须掌握)**==
+
+利用小写与小写字符中的差值为 32 进行转化。
+
+```cpp
+char upper = 'B';
+char lower = upper + 32; // 66 + 32 = 98 ('b')
+cout << lower << endl;   // 输出 b
+```
+
+==**案例 2：数字字符 转 整数数字**==
+这是算法题中非常常见的操作。因为数字字符在ASCII码里是连续的，所以任意一个 字符数字 和 字符0 之间的差值就是字符数字对应的整数数字。
+
+例如`'7' - '0' = 7, '4' - '0' = 4, '0' - '0' = 0`。
+
+```cpp
+char c_num = '8';
+int i_num = c_num - '0'; // '8'(56) - '0'(48) = 8
+cout << i_num << endl;   // 输出数字 8
+```
@@ -0,0 +1,168 @@
+## **C++ 类型转换 讲义**
+
+### 1. 引言
+
+*   **字符的储存**
+    字符 `'A'` 在计算机底层又是用哪个数字存储的呢？计算机的本质是处理数字，我们看到的所有文本、字符，在它眼中都是一个个特定的数字。最著名的编码表就是 **ASCII** (美国信息交换标准代码)，在书本P17页有部分的ASCII编码表可做参考。
+
+### 2. 核心思想
+
+**自动类型转换**
+我们有一个整数 `int number = 65;`。我们想得到它对应的字符。一个想法是：C++ 那么聪明，我直接把 `int` 赋值给 `char` 会怎么样？其实在 C++ 中，`char` 和 `int` 可以自由转换和运算。
+
+```cpp
+int number = 65;
+char c = number; // C++ 允许这样做，它会自动转换
+cout << c;       // 输出 'A'
+```
+
+这种由编译器自动完成的转换，叫做 **自动类型转化(隐式转换)**。在很多简单场景下，它完全没有问题！但是，这种有时会隐藏一些问题。如果代码很复杂，**其他人读到 `char c = 65;` 时，可能会疑惑：这是一个笔误吗？还是故意这么写的？为什么两边的数据类型不一样？**
+
+因为正常情况下，**赋值符号的右边的数据类型**应该和**左边的变量数据类型相匹配**。
+
+但是有些情况也可以不一致。源类型向目标类型转换时(例子中 `char c = number;` 源类型就是 `int` , 目标类型是`char`)。如果源类型和目标类型不一致，**在编译器知道怎么转换的情况下，会进行自动类型转换！**
+
+- **例如**：`int` 赋给 `double` 是安全的（`int` 转换为 `double`）。
+- **但请注意：** `double` 赋给 `int` 时，虽然编译器会尝试转换（截断小数部分），但这通常被认为是**不安全的**，因为它会丢失精度(小数点后的数据没有了)。
+- **整型和浮点型混合运算时，整型会向浮点型转换以避免数据丢失**。**核心原则是** “向高精度、大范围类型转换”，以避免数据丢失。例如，`int` 和 `double` 相加时，`int` 会被转换为 `double`。
+
+==**简单来说，C++的自动类型转换是尽力让你在不同的数据类型之间进行操作时，得到一个合理的结果，并且尽量不丢失数据。**==
+
+**强制类型转换(推荐使用！)**
+为了让我们的代码意图更加清晰，我们常常需要**强制类型转换**。
+
+这相当于我们明确地告诉编译器：**我需要在这里把这个值的类型变一下！**
+
+在 C++ 中，==强制类型转换语法==是：
+**`(目标类型) 变量名 或 数值`**
+
+- 例1：要把变量 `int number` 转换为 `char` 类型，我们就可以写：`(char)number`。
+- 例2：要把变量 `int number` 转换为 `double` 类型，我们就可以写：`(double)number`。
+
+**请注意：**如果我们想对 `a + b` 这种==**整个表达式的计算结果**==进行转换时，**就必须**使用括号 `()` 将表达式完整地包裹起来，写成 `(char)(a + b)`，以此来明确地告诉编译器：先算括号里的，再把算出来的最终结果进行转化！
+
+而不能写成 `(char)a + b`，如果这样写，**它会先把变量 `a` 转换为 `char` 类型**。然后再去去和变量 `b` 相加。和我们的目的：将 `a + b` 的结果转化为 `char` 类型就不符了。
+
+**步骤拆解**
+使用强制类型转换将数字转为字符的步骤很简单：
+
+1.  **准备一个整数**：定义一个 `int` 类型的变量，并存入一个在 ASCII 码范围内的数字。
+2.  **执行转换**：使用 `(char)(你的整数变量)` 来进行转换。
+3.  **存储结果**：将转换后的结果赋值给一个 `char` 类型的变量。
+4.  **输出验证**：打印输出这个 `char` 变量，看看结果是否符合预期。
+
+### 3. 实例
+
+*   **具体案例**
+    让我们把数字 `97` 转换为它对应的 ASCII 字符。
+
+*   **分步演示**
+    1.  **准备一个整数**：
+        ```cpp
+        int number = 97;
+        ```
+    2.  **执行转换**：我们使用强制类型转换。
+        ```cpp
+        (char)number // 这个表达式的结果就是字符 'a'
+        ```
+    3.  **存储结果**：
+        ```cpp
+        char res = (char)number;
+        ```
+    4.  **输出验证**：
+        ```cpp
+        cout << res; // 屏幕上将会打印出 a
+        ```
+
+### 4. 代码实现 
+
+现在，让我们把上面的步骤整合起来，写一个完整的程序。这个程序的作用是输入一个数字，输出这个数字在ASCII 码表中对应的字符。
+
+*   **完整代码**
+
+```cpp
+#include <iostream>
+using namespace std;
+int main() {
+    cout << "请输入一个整数 (例如 65 到 90 之间): ";
+    
+    // 定义变量并接收用户的输入
+    int number;
+    cin >> number;
+
+    // 使用强制类型转换
+    // 将 int 类型的 number 转换为 char 类型
+    char ascii_char = (char)number;
+
+    // 输出结果
+    cout << "数字 " << number << " 在 ASCII 码表中对应的字符是: " << ascii_char << endl;
+
+    return 0;
+}
+```
+
+### 5. 验证
+
+让我们用几个例子来测试一下我们的程序，看看会发生什么。
+
+*   **正常情况**：
+    *   输入 `65`，输出 `'A'`。
+    *   输入 `97`，输出 `'a'`。
+    *   输入 `48`，输出 `'0'`。
+*   **常见问题**
+    *   **问**：为什么不直接用 `char c = number;`？
+    *   **答**：在简单情况下可以，但它属于自动类型转化转换，意图不明确。像 `(char)number` 这样的强制转换，能让你的代码意图更清晰，一眼就能让人知道你是故意这样做的。
+    *   **问**：强制类型转换安全吗？
+    *   **答**：不一定。比方说： `double` 强制转换为 `int` 类型时，虽然编译器会转换（但是会截断小数部分）。所以，在转换前你要对数据的范围有的认识。例如你想转化一个整数到`char`字符类型，那就要确保这个整数的数值在ASCII码表中有对应的字符，如果这个数字根本不存在对应的字符，那计算机就也不知道应该如何转化了。
+
+---
+
+### **6. C++ 字符大小写转换（两种办法）**
+
+#### 一：直接观察法
+
+* 观察 ASCII 码表，你会发现一个规律：
+
+  *   `'A'` 是 65, `'a'` 是 97
+  *   `'B'` 是 66, `'b'` 是 98
+  *   ...
+  *   `'Z'` 是 90, `'z'` 是 122
+
+  **任意一个相同字母的小写形式，其 ASCII 码值都比大写形式大 32！** (`'a' - 'A' = 97 - 65 = 32`)
+
+  基于这个规律，我们有实现方式：
+
+  *   **==小写转大写==**：`大写字符 = 小写字符 - 32`
+  * **==大写转小写==**：`小写字符 = 大写字符 + 32`
+  * **案例：大小写转换**
+
+    ```cpp
+    char upper = 'B';
+    char lower = upper + 32; // 66 + 32 = 98 ('b')
+    cout << lower;   // 输出 b
+    ```
+
+#### **二：差值计算法**：
+
+例如想要将大写字符 `'C'`转为小写
+
+1.  **计算偏移量**：首先，我们需要知道目标字母 `'C'` 相对于大写字母起点 `'A'` 的“位置”或“差值量”。
+    *   这个偏移量可以通过减法计算得出：`'C' - 'A'`。我们知道结果是 `2`。这告诉我们，`'C'` 是排在 `'A'` 后面的第2个字母（从0开始计数）。
+
+2.  **找到新起点**：我们的目标是小写字母，那么小写字母的“起点”是谁？是 `'a'`。
+
+3.  **应用偏移量**：我们在新的起点 `'a'` 上，加上刚才计算出的差值量 `2`，就能得到我们想要的小写字母。
+    *   `'a' + ('C' - 'A')`
+    *   `'a' + 2`  -->  结果就是 `'c'`。
+
+*   **公式**：
+    *   **大写转小写**：`小写字母 = 任意大写字母 - 'A' + 'a'`
+    *   **小写转大写**：`大写字母 = 任意小写字母 - 'a' + 'A'`
+
+### 总结
+
+1.  字符在计算机底层是以数字（如 ASCII 码）存储的。
+2.  `char` 和 `int` 之间可以相互转换。
+3.  使用 `(目标类型)值` 的形式可以进行**强制类型转换**，这能让代码的意图更清晰。
+4.  进行类型转换时，要注意目标类型的**取值范围**，防止数据**溢出**，例如你想转化一个整数到`char`字符类型，那就要确保这个整数的数值在ASCII码表中有对应的字符，如果这个数字根本不存在对应的字符，那计算机就也不知道应该如何转化了。
+5.  英文字母的大小写形式在 ASCII 码表中具有固定的数值差 (`32`)。
@@ -0,0 +1,32 @@
+### **C++ 转义字符与字符类型 课后习题 - 答案**
+
+#### **一、 填空题**
+
+1.  `char`
+2.  单引号
+3.  `100`
+4.  `\\`
+5.  `\"Hi\"`
+6.  `':'`
+
+#### **二、 单项选择题**
+
+1.  **C**. `char` 类型的字面量必须用单引号包裹，且只能是单个字符。
+2.  **C**. `\n` 是换行符，会让 `Tom` 显示在下一行。
+3.  **B**. 反斜杠 `\` 本身是转义字符，要输出它自身，需要写成 `\\`。
+4.  **A**. `cin` 会依次读取一个整数存入 `a`，一个字符存入 `op`，一个整数存入 `b`。输入 `5+3` 时，`op` 会接收到字符 `'+'`。
+5.  **B**. `\"` 是双引号的转义序列，用于在字符串内部表示一个双引号字符。
+6.  **D**. `char` 变量只能存放单个字符，`'Go'` 包含两个字符，是错误的。
+7.  **A**. 程序读取一个整数 `h`，然后需要读取一个字符，最后读取一个整数 `m`。
+8.  **C**. `\\` 是 `\` 的转义序列，所以 `\\` 会让 `\` 失去转义功能，变回它本身。因此 `\\n` 会输出 `\n` 这两个字符。
+
+#### **三、 判断题**
+
+1.  × (必须用单引号 `' '`。)
+2.  √ (两者最终在屏幕上看到的换行效果是一样的。)
+3.  √ (`cin` 默认通过空白字符（空格、回车等）分隔数据，读到 'A' 后遇到空格，就完成了对 `c` 的读取。)
+4.  √ (这正是转义字符的定义。)
+5.  × ( `char` 只能存放单个字符。)
+6.  √ (`cin` 会先读取数字部分 `99` 存入 `a`，然后接着读取非数字字符 `'A'` 存入 `c`。)
+7.  √ ( `"` 是特殊字符，在字符串中必须通过 `\"` 来表示。)
+8.  √ (如 `cin >> a >> op >> b;` 所示，`cin` 可以很灵活地连续读取不同类型的数据。)
@@ -0,0 +1,78 @@
+### **C++ 转义字符与字符类型 课后习题**
+
+姓名: \_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_
+
+#### **一、 填空题**
+
+1.  C++中，用于存放单个字符（如 'A', '?'）的数据类型是 \_\_\_\_\_\_\_\_\_\_。
+2.  在为 `char` 类型变量赋值时，该字符必须被一对 \_\_\_\_\_\_\_\_\_\_（填“单引号”或“双引号”）包围。
+3.  代码 `cout << "Score:\n100";` 的输出结果是：第一行显示 `Score:`，第二行显示 \_\_\_\_\_\_\_\_\_\_。
+4.  如果想在屏幕上显示出路径 `D:\Data`，那么在代码的字符串中应该写作 `D:________Data`。
+5.  如果想在屏幕上显示出带引号的文字 `He said: "Hi"`，那么代码中表示 `"Hi"` 的部分应该写作 \_\_\_\_\_\_\_\_\_\_。
+6.  对于代码 `int h; char c; cin >> h >> c;`，如果用户输入 `12:59` 并回车，那么整型变量 `h` 的值是 `12`，而字符型变量 `c` 的值是 \_\_\_\_\_\_\_\_\_\_。
+
+#### **二、 单项选择题**
+
+( &nbsp; ) 1. 下面哪个是定义 `char` 变量并正确赋值的语句？
+    A. `char c = "A";`
+    B. `char c = A;`
+    C. `char c = 'A';`
+    D. `char c = 'AB';`
+
+( &nbsp; ) 2. 执行 `cout << "Name:\nTom";` 后，屏幕上会显示什么？
+    A. `Name:\nTom`
+    B. `Name: Tom`
+    C. 两行，第一行 `Name:`，第二行 `Tom`
+    D. `Name:Tom`
+
+( &nbsp; ) 3. 哪句代码可以在屏幕上正确输出路径 `C:\` ？
+    A. `cout << "C:\";`
+    B. `cout << "C:\\";`
+    C. `cout << "C:/";`
+    D. `cout << 'C:\';`
+
+( &nbsp; ) 4. 阅读以下代码，如果用户输入 `5+3` 并回车，变量 `op` 的值是多少？
+    ```cpp
+    int a, b;
+    char op;
+    cin >> a >> op >> b;
+    ```
+    A. `'+'`
+    B. `+`
+    C. `" "` (空格)
+    D. 程序会报错
+
+( &nbsp; ) 5. 执行 `cout << "He said \"Go!\"";` 后，屏幕上会显示什么？
+    A. `He said Go!`
+    B. `He said "Go!"`
+    C. `He said \"Go!\"`
+    D. `He said: "Go!"`
+
+( &nbsp; ) 6. 以下哪个**不能**被正确地赋值给一个 `char` 类型的变量？
+    A. `'?'`
+    B. `' '`
+    C. `'7'`
+    D. `'Go'`
+
+( &nbsp; ) 7. 有代码 `int h, m; char c; cin >> h >> c >> m;`，为了让程序成功读入小时 `11` 和分钟 `59`，不正确的输入格式是？
+    A. `11 59`
+    B. `11:59`
+    C. `11,59`
+    D. `11;59`
+
+( &nbsp; ) 8. 执行 `cout << "\\n";` 后，屏幕上会显示什么？
+    A. 一个空行
+    B. `n`
+    C. `\n`
+    D. `\`
+
+#### **三、 判断题 (对的打“√”，错的打“×”)**
+
+( &nbsp; ) 1. 在C++中，定义一个字符变量时，字符必须用双引号 `"` 包起来。
+( &nbsp; ) 2. `\n` 和 `endl` 都能在 `cout` 中实现换行的视觉效果。
+( &nbsp; ) 3. 对于 `char c; cin >> c;`，如果用户输入 `A B` 并回车，变量 `c` 的值会是 `'A'`。
+( &nbsp; ) 4. 转义字符 `\` 本身通常不会被显示，它的作用是改变其后字符的含义。
+( &nbsp; ) 5. 一个 `char` 类型的变量可以存放一个单词，比如 `'Hello'`。
+( &nbsp; ) 6. 对于 `int a; char c; cin >> a >> c;`，如果用户输入 `99A`，那么 `a` 的值是 `99`，`c` 的值是 `'A'`。
+( &nbsp; ) 7. 想输出双引号 `"`，代码必须写成 `cout << "\"";`。
+( &nbsp; ) 8. `cin` 可以一次性读取不同类型的变量，例如 `int` 和 `char`。
@@ -0,0 +1,28 @@
+### 参考答案
+
+#### **一、 填空题**
+
+1. `char`
+2. 单引号
+3. `66`
+4. `32`
+5. `5`
+6. `'+'`
+
+#### **二、 单项选择题**
+
+1. C
+2. C
+3. B (字符'C'的ASCII码是67，加1后是68，68对应的字符是'D')
+4. B
+5. B
+6. A
+
+#### **三、 判断题**
+
+1. × (一个是字符，一个是数字，它们的ASCII码和数值都不同)
+2. √
+3. √
+4. × (从'A'到'Z'，ASCII码是递增的)
+5. √
+6. × (`char` 只能存放单个字符)
@@ -0,0 +1,70 @@
+### C++ 字符与 ASCII 码 课后习题
+
+姓名: \_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_
+
+#### **一、 填空题**
+
+1.  在 C++ 中，我们使用关键字 \_\_\_\_\_\_\_\_ 来定义一个存放单个字符的变量。
+
+2.  定义一个字符变量时，字符本身必须用 \_\_\_\_\_\_\_\_ (填“单引号”或“双引号”) 括起来。
+
+3.  字符 `'A'` 对应的 ASCII 码值是 `65`，那么字符 `'B'` 对应的 ASCII 码值是 \_\_\_\_\_\_\_\_。
+
+4.  小写字母 `'a'` 的 ASCII 码值比大写字母 `'A'` 的 ASCII 码值大 \_\_\_\_\_\_\_\_。
+
+5.  阅读代码 `char c = '5'; int n = c - '0';`，执行后，整型变量 `n` 中存放的值是 \_\_\_\_\_\_\_\_。
+
+6.  在 `cin >> num1 >> op >> num2;` 中，如果用户输入 `10 + 20`，那么字符变量 `op` 中存入的值是 \_\_\_\_\_\_\_\_。
+
+#### **二、 单项选择题**
+
+( ) 1. 下列哪个是**正确**的字符变量定义语句？
+    A. `char c = "A";`
+    B. `char c = A;`
+    C. `char c = 'A';`
+    D. `int c = 'A';`
+
+( ) 2. 执行 `int ch = 'a';  cout << ch;` 后，屏幕上会显示什么？
+    A. `a`
+    B. `A`
+    C. `97`
+    D. `65`
+
+( ) 3. 阅读以下代码：
+    ```cpp
+    char letter = 'C';
+    letter = letter + 1;
+    cout << letter;
+    ```
+    程序的输出结果是？
+    A. `C`
+    B. `D`
+    C. `67`
+    D. `68`
+
+( ) 4. 如果想把大写字母 `'E'` 转换为对应的小写字母，正确的代码是？
+    A. `'E' - 32`
+    B. `'E' + 32`
+    C. `'E' - 'A'`
+    D. `'E' + 'a'`
+
+( ) 5. 在计算机内部，`char` 类型的变量实际上存放的是什么？
+    A. 字符的形状
+    B. 字符对应的 ASCII 码（一个整数）
+    C. 一段文字
+    D. 一个小数
+
+( ) 6. `int a; char op; cin >> a >> op;` 如果用户输入 `9*`，那么变量 `a` 和 `op` 的值分别是？
+    A. `a` 是 `9`，`op` 是 `'*'`
+    B. `a` 是 `'9'`，`op` 是 `'*'`
+    C. `a` 是 `9`，`op` 的值不确定
+    D. 读取会失败
+
+#### **三、 判断题 (对的打“√”，错的打“×”)**
+
+( ) 1. 在 C++ 中，字符 `'8'` 和整数 `8` 是完全一样的。
+( ) 2. 计算机能识别和处理文字，是因为有一张像 ASCII 码这样的“字符-数字”对照表。
+( ) 3. 数字字符是连续排列的，例如 `'1'` 的 ASCII 码比 `'0'` 的大 1。
+( ) 4. 大写字母 `'Z'` 的 ASCII 码比 `'A'` 的小。
+( ) 5. 因为字符本质上是数字，所以我们可以对 `char` 类型的变量进行加减运算。
+( ) 6. `char c = 'ab';` 这样的写法是正确的。
@@ -0,0 +1,27 @@
+### C++ 类型转换 课后习题 - **答案**
+
+#### **一、 填空题**
+
+1.  ASCII
+2.  自动类型
+3.  强制类型
+4.  目标类型
+5.  32
+6.  `(a + b)`
+
+#### **二、 单项选择题**
+
+1.  B    2. C    3. A    4. B    5. B    6. C    7. C    8. B    9. C    10. C
+
+#### **三、 判断题**
+
+1.  × (保存的是对应的数字，即ASCII码)
+2.  × (这是自动类型转换/隐式转换)
+3.  √
+4.  √
+5.  × (会丢失小数部分，是不安全的操作)
+6.  × (前者先转换x再加y，后者先算x+y再转换结果)
+7.  √
+8.  × (转换前需要了解数据范围，否则可能得到预期外的结果)
+9.  √
+10. √
@@ -0,0 +1,65 @@
+### C++ 类型转换 课后习题
+
+姓名: \_\_\_\_\_\_\_\_\_\_\_\_\_
+
+#### **一、 填空题**
+
+1.  计算机在存储字符（如 `'A'`）时，实际上存的是一个数字，这个数字是根据 \_\_\_\_\_\_\_\_\_\_\_\_\_ 码表来确定的。
+2.  例如`int a = 'A';`赋值符两边的类型不一致的情况，会由编译器完成类型转换，叫做 \_\_\_\_\_\_\_\_\_\_\_\_\_ 转换。
+3.  为了让代码的意图更清晰，我们通过 `(目标类型)变量名/数值` 的格式去进行类型类型的方式，叫做 **\_\_\_\_\_\_\_\_\_\_\_\_\_**转换。
+4.  强制类型转换的语法格式是：`(`\_\_\_\_\_\_\_\_\_\_\_\_\_`)变量名/数值`。
+5.  根据ASCII码表的规律，任意一个大写英文字母和它对应的小写字母，它们对应的数字相差 \_\_\_\_\_\_\_\_\_\_\_\_\_。
+6.  要把一个表达式 `a + b` 的计算**结果**整体转换为 `char` 类型，正确的写法是 `(char)`\_\_\_\_\_\_\_\_\_\_\_\_\_。
+
+#### **二、 单项选择题**
+
+(     ) 1. 执行 `cout << (char)65;` 这行代码，屏幕上会输出什么？
+    A. 65    	B. 'A'    	C. 'a'    	D. 无法输出
+
+(     ) 2. 执行 `cout << (int)'a';` 这行代码，屏幕上会输出什么？
+    A. 'a'    	B. 65   	 C. 97   	 D. 32
+
+(     ) 3. 要将大写字母 `'C'` 转换为小写字母 `'c'`，正确的计算方法是？
+    A. `'C' + 32`    B. `'C' - 32`    C. `'C' + 'a'`    D. `'C' - 'A'`
+
+(     ) 4. 要将小写字母 `'z'` 转换为大写字母 `'Z'`，正确的计算方法是？
+    A. `'z' + 32`    B. `'z' - 32`    C. `'z' + 'A'`    D. `'z' - 'a'`
+
+(     ) 5. 当一个 `double` 类型的变量（如 `3.14`）被转换为 `int` 类型时，会发生什么？
+    A. 四舍五入，变为 3
+    B. 丢失小数部分，变为 3
+    C. 四舍五入，变为 4
+    D. 程序会报错
+
+(     ) 6. 表达式 `(char)('B' + 1)` 的计算结果是什么？
+    A. 'B'    	B. 'A'    	C. 'C'    	D. 2
+
+(     ) 7. 相比于 `char c = 97;`，使用 `char c = (char)97;` 这种写法的优点是？
+    A. 运行速度更快
+    B. 程序占用的内存更小
+    C. 代码的意图更清晰明确
+    D. 没有任何区别
+
+(     ) 8. 差值计算法中，`'D' - 'A'` 这个表达式的含义是？
+    A. 字母D减去字母A
+    B. 计算D和A的ASCII码值的差
+    C. 这是一个错误写法
+    D. 结果等于 `'C'`
+
+(     ) 9. 当一个 `int` 类型的数和一个 `double` 类型的数做加法时，`int` 类型会自动转换为哪个类型？
+    A. `char`    	B. `int`    	C. `double`    	D. 不会转换
+
+(     ) 10. `cout << (char)48;` 会在屏幕上输出什么字符？
+    A. 'a'    	B. 'A'    	C. '0'    	D. '1'
+
+#### **三、 判断题 (对的打“√”，错的打“×”)**
+(     ) 1. 计算机在保存字符 `'A'` 时，就是保存了字母A的图片信息。
+(     ) 2. `char c = 65;` 这种写法属于强制类型转换。
+(     ) 3. 在ASCII码表中，所有小写字母对应的数字都比对应的大写字母要大。
+(     ) 4. 表达式 `'a' - 'A'` 的计算结果是 `32`。
+(     ) 5. 把一个小数（`double`）赋值给一个整数（`int`）是一种安全的操作，不会丢失任何数据。
+(     ) 6. `(char)x + y` 和 `(char)(x + y)` 的计算过程和结果是完全一样的。
+(     ) 7. `'Y' + 32` 的计算结果是小写字母 `'y'`。
+(     ) 8. 使用 `(char)num` 进行强制类型转换前，我们不需要关心 `num` 的值是多少，转换总是安全的。
+(     ) 9. `'a' + ('C' - 'A')` 这个表达式可以把大写字母 `'C'` 转换为小写字母 `'c'`。
+(     ) 10. 字符不仅可以和数字进行转换，字符之间也可以进行加减运算。