《星火征途》初赛模拟卷（二）

一、单选题（每题5分，共75分）

1. 以下不可以作为C++标识符的是（ B ）

A. redArmy      // 合法：字母开头，包含字母和下划线
B. 3rdBattalion // 非法：数字开头！
C. _march       // 合法：下划线开头
D. hero_1       // 合法：字母开头，包含数字和下划线

【答案：B】

• A. redArmy ✅ 合法标识符：以小写字母开头，由字母组成
• B. 3rdBattalion ❌ 非法！ C++规定标识符必须以字母（a-z, A-Z）或下划线（_）开头，不能以数字开头
• C. _march ✅ 合法：以下划线开头是允许的（虽然不推荐用于普通变量）
• D. hero_1 ✅ 合法：字母开头，可包含字母、数字、下划线的组合

---

2. 常量 7.0 的数据类型是（ C ）

【答案：C】

• A. int ❌ 整型常量写作 7（无小数点）
• B. float ❌ 单精度浮点数通常写作 7.0f 或 7.0F（需要f后缀）
• C. double ✅ 正确！在C++中，带小数点的字面量默认是 double（双精度浮点型）
• D. void ❌ 空类型，不是数据类型，不能存储值

💡 知识点扩展：

• 7 → int 类型
• 7.0 → double 类型（默认）
• 7.0f → float 类型
• 7.0L → long double 类型

---

3. 关于 cin 和 cout，以下说法正确的是（ C ）

A. cin 用 << 接收输入        // 错误方向
B. cout 用 >> 输出内容        // 错误方向
C. cin 用 >> 接收输入，cout 用 << 输出内容  // 正确！
D. cin 和 cout 都用 <<        // 不完全正确

【答案：C】

• A. cin 用 << 接收输入 ❌ 方向错误！<< 是插入运算符（向输出流插入数据）
• B. cout 用 >> 输出内容 ❌ 方向错误！>> 是提取运算符（从输入流提取数据）
• C. cin 用 >> 接收输入，cout 用 << 输出内容 ✅ 完全正确！
  • cin >> variable ：从标准输入（键盘）提取数据到变量
  • cout << data ：将数据插入到标准输出（屏幕）
• D. cin 和 cout 都用 << ❌ cin 必须用 >>

🎯 记忆技巧： 箭头方向表示数据流动方向

• cin >> x ：数据从 cin 流向 x（输入）
• cout << x ：数据从 x 流向 cout（输出）

---

4. 如果 a 为 int 类型且 a=6，执行 a %= 4; 后，a 的值是（ B ）

计算过程：
a = 6
a %= 4   等价于 a = a % 4 = 6 % 4
6 ÷ 4 = 1 余 2
所以 a = 2

【答案：B】

• A. 1 ❌ 这是商（6/4的结果），不是余数
• B. 2 ✅ 正确！% 是取模（取余）运算符，6 % 4 = 2
• C. 3 ❌ 计算错误
• D. 4 ❌ 这是除数，不是结果

💡 取模运算 % 的应用场景：

• 判断奇偶：n % 2 == 0 （偶数）
• 循环数组索引：index % size
• 提取数字的个位：n % 10

---

5. 计算正方形训练场面积，以下表达式错误的是（ C ）

int a;  // 边长
A. a * a           // 正确：边长的平方
B. 1 * a * a       // 正确：等价于 a * a
C. a ^ 2           // 错误！^ 是位异或，不是幂运算
D. a * 2 * a / 2   // 正确：化简后 = a * a

【答案：C】

• A. a * a ✅ 正确！这是计算平方的标准写法
• B. 1 * a * a ✅ 正确！乘法满足结合律，结果等于 a²
• C. a ^ 2 ❌ 严重错误！ 在C++中，^ 不是幂运算符，而是**按位异或（XOR）**运算符！
  • 例如：3 ^ 2 = (011) XOR (010) = 001 = 1（不是9）
  • 要计算幂应该用 pow(a, 2) 或直接 a * a
• D. a * 2 * a / 2 ✅ 正确！(a * 2 * a) / 2 = (2a²) / 2 = a²

⚠️ 常见陷阱： 很多初学者以为 ^ 是幂运算，其实在C/C++/Java中都是位异或！

---

6. 下列表达式不能正确判断"a 等于 0 且 b 等于 0"的是（ B ）

假设 a=0, b=0：

A. (a == 0) && (b == 0)    // (true) && (true) = true  ✓
B. (a == b == 0)            // (0 == 0) == 0 → true == 0 → false  ✗
C. (!a) && (!b)             // (!0)=true && (!0)=true = true  ✓
D. (a == 0) + (b == 0) == 2  // true(1) + true(1) = 2, 2==2 → true  ✓

【答案：B】

• A. (a == 0) && (b == 0) ✅ 标准写法，逻辑与判断两个条件同时成立

• B. (a == b == 0) ❌ 陷阱！ 这个表达式会从左到右计算：

  1. 先算 a == b → 0 == 0 → true（在C++中true转换为1）
  2. 再算 1 == 0 → false
  3. 最终结果是 false，即使 a 和 b 都是0！

• C. (!a) && (!b) ✅ !0 = true，两个true做逻辑与 = true

• D. (a == 0) + (b == 0) == 2 ✅ 比较表达式的结果可以参与算术运算（true=1, false=0），1+1=2，2==2为true

💡 为什么选项B是错的？ 因为连续比较 a == b == 0 不等于数学上的 "a=b=0"！ 在编程中必须用 && 连接多个条件。

---

7. 红军根据天气决定行军计划（ A ）

int weather = 1;   // 1=晴天
int enemy = 0;     // 0=无敌情
if (weather == 1) {              // weather==1? Yes!
    if (enemy == 0) {            // enemy==0? Yes!
        cout << "出发行军";      // ← 执行这个！
    } else {
        cout << "待命观察";
    }
} else {
    cout << "原地休整";
}

【答案：A】

• A. 出发行军 ✅ 正确！嵌套if判断：

  • 外层：weather == 1 为真（晴天）✓
  • 内层：enemy == 0 为真（无敌情）✓
  • 所以输出 "出发行军"

• B. 待命观察 ❌ 需要 enemy != 0 才会执行

• C. 原地休整 ❌ 需要 weather != 1 才会执行

• D. 无输出 ❌ 肯定会有输出

---

8. 三目运算符求最大值（ B ）

int a = 120, b = 85;
int maxVal = (a > b) ? a : b;
// 判断：120 > 85 ? Yes! → 返回 a (120)
cout << maxVal << endl;  // 输出 120

【答案：B】

• A. 85 ❌ 这是较小值

• B. 120 ✅ 正确！三目运算符 (条件) ? 值1 : 值2

  • 条件 a > b 即 120 > 85 为 true
  • 返回值1：a = 120

• C. 205 ❌ 这是 a+b 的结果

• D. 35 ❌ 这是 a-b 的结果

💡 三目运算符常用于求最大/最小值、简单条件赋值等场景。

---

9. for循环执行次数（ B ）

for (int i = 0; i < 10; i += 2)
// i 的取值：0, 2, 4, 6, 8
// 当 i=10 时，10<10 为 false，退出
// 共执行 5 次

【答案：B】

• A. 4 ❌ 少算了一次
• B. 5 ✅ 正确！i 取值为 0, 2, 4, 6, 8，共5次循环
• C. 10 ❌ 如果是 i++ 才会是10次（0~9）
• D. 2 ❌ 明显不对

---

10. while循环输出（ D ）

int x = 100;
while (x > 10) {
    x = x / 2;    // 整除
}

// 执行过程：
// 第1轮: x=100, 100>10 ✓, x=100/2=50
// 第2轮: x=50,  50>10  ✓, x=50/2=25
// 第3轮: x=25,  25>10  ✓, x=25/2=12
// 第4轮: x=12,  12>10  ✓, x=12/2=6
// 第5轮: x=6,   6>10   ✗, 退出循环
// 输出 x = 6

【答案：D】

• A. 100 ❌ 第一次循环就改变了x的值
• B. 50 ❌ 只是第一次循环后的值
• C. 12 ❌ 第4轮后 x=12，但还会再执行一轮：12>10 成立，x=12/2=6
• D. 6 ✅ 正确！循环结束时 x=6（6>10 不成立，退出）

---

11. do-while求和（ B ）

int sum = 0;
int i = 1;
do {
    sum += i;   // sum = 0+1=1, 1+2=3, 3+3=6
    i++;         // i = 2, 3, 4
} while (i <= 3);  // i=4时，4<=3为false，退出
// 输出 sum = 6

【答案：B】

• A. 3 ❌ 只加了最后一次的i值
• B. 6 ✅ 正确！1+2+3 = 6
• C. 10 ❌ 这是1+2+3+4的结果
• D. 1 ❌ 只加了初始值

---

12. 类型转换表达式（ B ）

double(a) / 2
// 步骤1: double(a) 将int类型的a(5)转换为double类型 5.0
// 步骤2: 5.0 / 2 = 2.5（浮点除法）

【答案：B】

• A. 2 ❌ 这是整数除法 5 / 2 的结果
• B. 2.5 ✅ 正确！double(a) 将a提升为double类型，然后进行浮点除法
• C. 3 ❌ 无此可能
• D. 2.0 ❌ 虽然2.5可以写成2.5，但2.0是不精确的

💡 关键概念：整数提升（Integer Promotion）

• 5 / 2 → 两个int相除 → 结果int → 2（截断小数）
• double(5) / 2 → double ÷ int → int自动提升为double → 2.5
• 5.0 / 2 → 同上 → 2.5

---

13. 数组元素修改（ B ）

int arr[5] = {10, 20, 30, 40, 50};
// 下标:      [0] [1] [2] [3]  [4]
arr[2] = 100;          // 修改下标2的元素：30 → 100
cout << arr[2] << endl; // 输出新值 100

【答案：B】

• A. 30 ❌ 这是修改前的原始值
• B. 100 ✅ 正确！arr[2] = 100; 将数组第3个元素（下标2）改为100
• C. 2 ❌ 这是下标，不是元素值
• D. 3 ❌ 无意义

💡 数组基础：

• C++数组下标从 0 开始
• arr[5] 定义了5个元素，有效下标：0, 1, 2, 3, 4
• 可以通过下标直接访问和修改元素

---

14. 二维数组访问（ B ）

int grid[3][2] = {{1,2},   // 第0行
                   {3,4},   // 第1行
                   {5,6}};  // 第2行
// grid[行][列]
// grid[1][0] 表示第1行第0列 = 3

【答案：B】

• A. 1 ❌ 这是 grid[0][0]
• B. 3 ✅ 正确！grid[1][0] 表示第1行的第0列元素
• C. 4 ❌ 这是 grid[1][1]
• D. 5 ❌ 这是 grid[2][0]

💡 二维数组可视化：

     列0  列1
行0: [ 1 ,  2 ]
行1: [ 3 ,  4 ]  ← grid[1][0]=3, grid[1][1]=4
行2: [ 5 ,  6 ]

---

15. 字符串长度（ C ）

string s1 = "Red";     // 长度3
string s2 = "Army";    // 长度4
string s3 = s1 + s2;   // 拼接："RedArmy"，长度7
cout << s3.length();   // 输出 7

【答案：C】

• A. 5 ❌ 计算错误
• B. 6 ❌ 可能漏算了某个字符
• C. 7 ✅ 正确！"Red"(3字符) + "Army"(4字符) = "RedArmy"(7字符)
• D. 8 ❌ 多算了

💡 string 类常用方法：

• s.length() 或 s.size() → 返回字符串长度
• s1 + s2 → 字符串拼接
• s == t → 字符串相等比较

---

二、判断题（每题5分，共25分）

---

16. 两个 int 类型变量相除，结果仍为 int 类型，小数部分直接舍去。（ ✓ 正确 ）

【答案：正确 ✓】 解析：

• C++中，两个整数相除，结果仍然是整数（截断小数，不是四舍五入）

int a = 7, b = 2;
cout << a / b;    // 输出 3（不是3.5）
cout << a % b;    // 输出 1（余数）

• 这就是为什么 137 / 12 = 11（商），137 % 12 = 5（余数）
• 要得到小数结果：至少一个操作数必须是浮点型
  • 7.0 / 2 → 3.5
  • (double)a / b → 3.5

---

17. if-else if-else 结构中，一旦某个条件满足并执行对应语句后，会跳出整个结构。（ ✓ 正确 ）

【答案：正确 ✓】 解析：

• if-else if-else 是互斥的多分支结构
• 从上到下依次判断条件，一旦某个条件为真：
  1. 执行对应的代码块
  2. 跳过后续所有 else if 和 else 分支
  3. 继续执行结构之后的代码

int score = 75;
if (score >= 90) cout << "A";      // false，跳过
else if (score >= 60) cout << "B"; // true！执行后跳出
else cout << "C";                  // 不会执行

• 这保证了只有一个分支会被执行

---

18. C++中 sort(arr, arr+5) 可以将数组 arr 的前5个元素从小到大排序。（ ✓ 正确 ）

【答案：正确 ✓】 解析：

• sort() 是C++标准库 <algorithm> 中的排序函数
• 语法：sort(起始地址, 结束地址)
• sort(arr, arr+5) 表示对 arr[0] 到 arr[4] 共5个元素排序

#include <algorithm>
int arr[5] = {50, 20, 80, 10, 40};
sort(arr, arr + 5);
// 排序后：{10, 20, 40, 50, 80}

• 默认是升序排列（从小到大）
• 如需降序：sort(arr, arr+5, greater<int>())

---

19. 将二进制数 1011 转换为十进制，结果是13。（ ✗ 错误 ）

【答案：错误 ✗】 解析：

• 正确的转换过程：

二进制: 1  0  1  1
权重:   8  4  2  1  (2³ 2² 2¹ 2⁰)
计算:  1×8 + 0×4 + 1×2 + 1×1
     = 8 + 0 + 2 + 1
     = 11  ← 正确答案是11，不是13！

• 常见错误： 可能把某一位算错了，或者混淆了其他二进制数
• 二进制 1011 = 十进制 11
• 二进制 1101 = 十进制 13（可能是记混了）

---

20. 冒泡排序每一轮都是将当前最大的元素"冒"到未排序部分的末尾。（ ✓ 正确 ）

【答案：正确 ✓】 解析：

• 冒泡排序原理：

  1. 从前往后相邻两两比较
  2. 如果前一个比后一个大，则交换
  3. 每一轮结束后，最大的元素会"冒泡"到最后面
  4. 下一轮对剩下的 n-1 个元素重复此过程

• 示例（5个元素）：

初始: [5, 3, 8, 1, 2]
第1轮: [3, 5, 1, 2, **8**]  ← 8冒到最后
第2轮: [3, 1, 2, **5**, 8]  ← 5冒到倒数第二
第3轮: [1, 2, **3**, 5, 8]
第4轮: [1, **2**, 3, 5, 8]
结果: [**1**, 2, 3, 5, 8]

• 就像水中的气泡一样，大的元素慢慢"浮"到表面！