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

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

1. 常量 '3' 的数据类型是（ C ）

【答案：C】

• A. int ❌ 整型常量写作 3（无引号）
• B. double ❌ 浮点型常量写作 3.0 或 3.14
• C. char ✅ 正确！用单引号包裹的是字符常量（char类型）

  char c = '3';    // 字符'3'，ASCII码值为51
  int n = 3;       // 整数3
  

• D. string ❌ 字符串常量用双引号："3"

💡 字符 vs 整数 vs 字符串： | 写法 | 类型 | 值 | |------|------|-----| | 3 | int | 数字3 | | '3' | char | 字符'3'（ASCII码51） | | "3" | string | 包含一个字符的字符串 |

---

2. 以下变量定义中，正确的是（ B ）

A. int 2a = 10;           // ❌ 数字开头
B. double price = 9.8;     // ✅ 完全正确
C. char letter = "A";      // ❌ 双引号用于string，char应该用单引号
D. int class = 5;          // ❌ class是关键字

【答案：B】

• A. int 2a = 10; ❌ 非法！ 标识符不能以数字开头，必须以字母或下划线开头

• B. double price = 9.8; ✅ 完全正确！

  • price 是合法标识符（字母开头）
  • double 匹配浮点数值 9.8

• C. char letter = "A"; ❌ 类型不匹配！

  • "A" 是字符串字面量（const char*），不是char
  • char 应该使用单引号：char letter = 'A';

• D. int class = 5; ❌ 非法！ class 是C++保留关键字（用于定义类），不能作为变量名

⚠️ 常见关键字不能用作变量名： int, float, double, char, if, else, for, while, class, return, void, true, false...

---

3. 红军指挥部发出行军指令，以下代码的输出结果是（ B ）

cout << "向" << "前" << "进" << endl;

【答案：B】

• A. 向 前进 ❌ 多了一个空格

• B. 向前进 ✅ 正确！多个字符串连续输出会紧密拼接，中间不会自动加空格

  • 输出过程：先输出 "向"，再拼接 "前"，再拼接 "进"，最后换行
  • 最终结果：向前进

• C. 向 前 进 ❌ 除非代码写成 cout << "向" << " " << "前" << " " << "进";

• D. 编译错误 ❌ 这是完全合法的链式输出操作

---

4. 红军有360发子弹，平均分给8个战斗小组，以下表达式结果为45的是（ B ）

360发子弹 ÷ 8个小组 = 每组45发
这是除法运算，求商

【答案：B】

• A. 360 % 8 ❌ 取余运算，结果是 0（360能被8整除）

  • 验证：360 = 8 × 45 + 0

• B. 360 / 8 ✅ 正确！整数除法，结果为 45（商）

  • 360 ÷ 8 = 45（每组45发子弹）

• C. 360 - 8 ❌ 结果为352

• D. 360 * 8 ❌ 结果为2880

📝 应用场景区分：

• 需要每组多少 → 用 / （除法求商）→ 360/8=45
• 还剩多少 → 用 % （取模求余）→ 360%8=0

---

5. 如果 a 为 int 类型且 a=6，执行 a *= 3; 后，a 的值是（ D ）

int a = 6;
a *= 3;      // 等价于 a = a * 3 = 6 * 3 = 18

【答案：D】

• A. 3 ❌ 这是右边的操作数
• B. 6 ❌ 这是原始值，没有更新
• C. 9 ❌ 这是 6+3 的结果
• D. 18 ✅ 正确！a *= 3 是复合赋值运算符，等价于 a = a * 3
  • 计算：6 × 3 = 18

💡 复合赋值运算符一览表： | 运算符 | 示例 | 等价于 | |--------|------|--------| | += | 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 |

---

6. 红军两个连队，一连120人，二连85人。以下表达式能正确判断"一连人数多于二连"的是（ C ）

一连: 120人
二连: 85人
判断条件: 120 > 85 ? (true)

【答案：C】

• A. 120 = 85 ❌ 语法错误！ 单个 = 是赋值运算符，不是比较！

  • 这会把85赋值给120（实际上编译错误，不能给字面量赋值）
  • 即使编译通过，结果也是false（因为85被当作布尔值）

• B. 120 == 85 ❌ 判断相等，结果为 false（120不等于85）

• C. 120 > 85 ✅ 正确！大于运算符 > 用于判断大小关系

  • 120 > 85 → true ✓（一连确实比二连人多）

• D. 120 >= 85 && 120 <= 85 ❌ 逻辑矛盾！

  • 120 >= 85 → true
  • 120 <= 85 → false
  • true && false → false

🎯 比较运算符总结：

• == 相等、!= 不等
• < 小于、> 大于
• <= 小于等于、>= 大于等于

---

7. 红军根据侦察结果选择行动方案（ B ）

int score = 75;
if (score >= 90) cout << "A";       // 75>=90? No! 跳过
else if (score >= 60) cout << "B";  // 75>=60? Yes! 输出B
else cout << "C";                    // 不会执行到这里

【答案：B】

• A. A ❌ 需要 score >= 90 才输出A

• B. B ✅ 正确！if-else if-else 结构：

  1. 第一个条件 score >= 90 → 75 >= 90 → false，跳过
  2. 第二个条件 score >= 60 → 75 >= 60 → true，执行并输出 "B"
  3. 跳出整个结构，后面的else不再判断

• C. C ❌ 需要 score < 60 才输出C

• D. AB ❌ 只会执行一个分支，不会同时输出两个

💡 这个例子展示了成绩等级判定：

• A级：90-100分
• B级：60-89分 ← 75分属于这个范围
• C级：0-59分

---

8. 红军行军途中记录经过的桥梁数（ B ）

int count = 0;
for (int i = 1; i <= 10; i++) {
    if (i % 3 == 0) {   // i能否被3整除？
        count++;         // 能的话计数+1
    }
}
// i=1~10中，能被3整除的有：3, 6, 9
// 共3个
cout << count << endl;   // 输出 3

【答案：B】

• A. 2 ❌ 少数了

• B. 3 ✅ 正确！在1到10中：

  • 3 % 3 == 0 ✓ （count=1）
  • 6 % 3 == 0 ✓ （count=2）
  • 9 % 3 == 0 ✓ （count=3）
  • 总共 3 个数能被3整除

• C. 4 ❌ 多算了（可能把12也算上了？但i只到10）

• D. 5 ❌ 明显不对

---

9. 观察以下代码（ A ）

int n = 5;
while (n > 0) {
    cout << n << " ";
    n -= 2;        // n每次减2
}

// 执行过程：
// n=5:  5>0✓, 输出5,  n=3
// n=3:  3>0✓, 输出3,  n=1
// n=1:  1>0✓, 输出1,  n=-1
// n=-1: -1>0✗, 退出循环
// 输出: 5 3 1

【答案：A】

• A. 5 3 1 ✅ 正确！n从5开始，每次减2，直到n≤0时停止
• B. 5 3 1 -1 ❌ -1时不满足条件，不会输出
• C. 5 4 3 2 1 ❌ 这是 n-- 的结果，但这里是 n -= 2
• D. 无限循环 ❌ n在不断减小，最终会变成负数退出

---

10. 观察以下代码（ B ）

int a = 0;
do {
    a++;
} while (a < 0);
cout << a << endl;

// do-while特点：先执行一次，再判断条件
// 第1次：a=0→1（执行a++），然后判断 1<0? false，退出
// 输出: 1

【答案：B】

• A. 0 ❌ a++已经执行过了，a已经变成1

• B. 1 ✅ 正确！do-while保证至少执行一次循环体：

  1. 进入循环体，执行 a++，a从0变为1
  2. 判断条件 a < 0 即 1 < 0 → false
  3. 退出循环
  4. 输出 a = 1

• C. -1 ❌ a只会递增，不会变成负数

• D. 无限循环 ❌ 条件第一次就为假，立即退出

🔑 do-while的关键特性：

• 至少执行1次循环体（即使条件一开始就为假）
• 适用场景：需要先执行再判断的情况（如输入验证）

---

11. 表达式 double(7) / 2 的结果是（ B ）

计算步骤：
1. double(7): 将整数7转换为double类型 7.0
2. 7.0 / 2: 一个double除以int，int自动提升为double
3. 7.0 / 2.0 = 3.5（浮点除法）

【答案：B】

• A. 3 ❌ 这是 7 / 2（整数除法）的结果
• B. 3.5 ✅ 正确！类型转换后进行浮点除法
• C. 4 ❌ 无此可能
• D. 3.0 ❌ 虽然接近但不精确，实际是3.5

💡 为什么结果是3.5而不是3？

• 7 / 2 → 两个int → 整数除法 → 3（截断小数）
• double(7) / 2 → double ÷ int → int提升为double → 3.5
• 这就是显式类型转换的作用！

---

12. 红军通讯兵根据信号等级传递情报（ D ）

int signal = 4;
switch (signal) {
    case 1: cout << "一般"; break;    // signal≠1
    case 2: cout << "重要"; break;    // signal≠2
    case 3: cout << "紧急"; break;    // signal≠3
    default: cout << "未知"; break;   // 所有case都不匹配，执行default
}

【答案：D】

• A. 一般 ❌ signal=1才执行
• B. 重要 ❌ signal=2才执行
• C. 紧急 ❌ signal=3才执行
• D. 未知 ✅ 正确！switch匹配流程：
  • signal = 4
  • 与 case 1 比较：4 ≠ 1 → 跳过
  • 与 case 2 比较：4 ≠ 2 → 跳过
  • 与 case 3 比较：4 ≠ 3 → 跳过
  • 所有case都不匹配 → 执行 default 分支 → 输出 "未知"

📝 switch-case结构要点：

• 从上到下依次匹配case标签
• 匹配成功后执行对应代码（直到遇到break或结束）
• 如果所有case都不匹配，执行default（如果有的话）
• default是可选的，但推荐加上处理意外情况

---

13. 红军需要输出3行3列的队形（ B ）

for (int i = 0; i < 3; i++) {         // 外层控制行（3行）
    for (int j = 0; j < 3; j++) {     // 内层控制列（3列）
        cout << (i * 3 + j + 1) << " ";
    }
    cout << endl;
}
// 计算每行的输出：
// i=0(第1行): j=0→1, j=1→2, j=2→3   输出: 1 2 3
// i=1(第2行): j=0→4, j=1→5, j=2→6   输出: 4 5 6
// i=2(第3行): j=0→7, j=1→8, j=2→9   输出: 7 8 9

【答案：B】

• A. 1 2 3 ❌ 这是第一行的输出

• B. 4 5 6 ✅ 正确！第二行（i=1）的输出：

  • 当 i=1 时：
    • j=0: 1×3 + 0 + 1 = 4
    • j=1: 1×3 + 1 + 1 = 5
    • j=2: 1×3 + 2 + 1 = 6
  • 所以第二行输出 4 5 6

• C. 7 8 9 ❌ 这是第三行的输出

• D. 3 4 5 ❌ 计算错误

💡 公式 i * 3 + j + 1 的含义：

• i * 3：跳过前面完整的几行（每行3个数）
• + j：当前行的第几个位置
• + 1：因为编号从1开始（不是从0）

---

14. 红军一维数组记录5名战士的得分（ B ）

int score[5] = {85, 92, 78, 95, 88};
int total = 0;
for (int i = 0; i < 5; i++) {
    total += score[i];   // 累加每个元素
}
// total = 0 + 85 + 92 + 78 + 95 + 88 = 438
cout << total << endl;

【答案：B】

• A. 85 ❌ 只是第一个元素

• B. 438 ✅ 正确！数组遍历累加：

  • score[0]=85, total=85
  • score[1]=92, total=177
  • score[2]=78, total=255
  • score[3]=95, total=350
  • score[4]=88, total=438

• C. 5 ❌ 这是元素个数或循环次数

• D. 88 ❌ 只是最后一个元素

📊 数组遍历求和模式：

int sum = 0;
for (int i = 0; i < n; i++) {  // n是数组长度
    sum += arr[i];             // 累加每个元素
}

---

15. 红军定义结构体记录战士信息（ A ）

struct Soldier {
    string name;   // 姓名
    int age;       // 年龄
    double score;  // 得分
};
Soldier s;
s.name = "小王";
s.age = 16;
s.score = 95.5;
cout << s.name << " " << s.age << endl;
// 输出: 小王 16

【答案：A】

• A. 小王 16 ✅ 正确！s.name 是 "小王"，s.age 是 16

  • 用空格分隔输出

• B. 小王 95.5 ❌ 输出的是 age 不是 score

• C. 16 95.5 ❌ 顺序反了，且缺少name

• D. 编译错误 ❌ 代码完全合法

💡 结构体（struct）基础：

• 结构体是用户自定义的数据类型，可以包含多个不同类型的成员
• 使用 . 运算符访问成员：变量名.成员名
• 常用于组织相关的数据（如学生信息、坐标点等）

---

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

---

16. int a = 7; a /= 2; 执行后 a 的值为3。（ ✓ 正确 ）

【答案：正确 ✓】 解析：

• a /= 2 是复合赋值运算符，等价于 a = a / 2
• 计算过程：

  初始: a = 7
  a /= 2  →  a = 7 / 2
         →  a = 3（整数除法，截断小数部分）
  

• 最终 a = 3 ✅

💡 注意： 如果想要得到3.5的结果，需要使用浮点数：

double b = 7;
b /= 2;   // b = 3.5

---

17. C++中二维数组 int grid[3][2] 表示3行2列的表格，下标从0开始。（ ✓ 正确 ）

【答案：正确 ✓】 解析：

• 二维数组声明格式： 类型 数组名[行数][列数]

• int grid[3][2] 的含义：

  • 3行（第一个维度）：有效下标 0, 1, 2
  • 2列（第二个维度）：有效下标 0, 1
  • 总共 3 × 2 = 6 个元素

• 可视化表示：

       列0   列1
  行0: [0,0] [0,1]
  行1: [1,0] [1,1]
  行2: [2,0] [2,1]

• 访问方式： grid[行下标][列下标]
• 内存存储： 按行优先顺序存储（先存完第0行，再存第1行...）

---

18. 枚举法就是将所有可能的情况一一列举出来，逐一判断是否满足条件。（ ✓ 正确 ）

【答案：正确 ✓】 解析：

• 枚举法（Enumeration/暴力搜索） 是最基础的算法思想

• 核心思想：

  1. 列举问题的所有可能解（或所有可能的候选情况）
  2. 逐一验证每个候选是否满足题目要求
  3. 记录或输出满足条件的解

• 适用场景：

  • 可能的情况数量有限且较少
  • 问题规模较小（通常 n ≤ 10⁶）
  • 没有明显的数学规律可循

• 示例：找出100以内所有的质数

for (int i = 2; i <= 100; i++) {     // 枚举2~100的所有数
    bool isPrime = true;
    for (int j = 2; j * j <= i; j++) {  // 逐一检验
        if (i % j == 0) {
            isPrime = false;
            break;
        }
    }
    if (isPrime) cout << i << " ";  // 输出满足条件的
}

• 优点： 思路简单直观，不易出错，一定能找到正确答案
• 缺点： 时间复杂度高，不适合大规模数据
• 优化方向： 减少枚举范围、剪枝（提前终止不可能的分支）

---

19. strcpy(a, b) 的功能是将字符串 b 复制到字符数组 a 中。（ ✓ 正确 ）

【答案：正确 ✓】 解析：

• strcpy() 是C标准库 <cstring> 中的字符串复制函数

• 函数原型：

char* strcpy(char* destination, const char* source);

• 功能说明：

  • 将 source（源字符串）完整复制到 destination（目标字符数组）
  • 包括结尾的 \0（空字符）也会一起复制
  • 返回指向 destination 的指针

• 使用示例：

#include <cstring>
char src[] = "Hello";
char dest[20];
strcpy(dest, src);   // dest现在也变成了"Hello"
cout << dest;        // 输出: Hello

• ⚠️ 安全隐患： strcpy不检查目标缓冲区大小，可能导致缓冲区溢出

  • 更安全的替代：strncpy(dest, src, sizeof(dest)-1)

• 在C++中更推荐： 使用 string 类和赋值运算符

string a = "Hello";
string b = a;  // 安全地复制字符串

---

20. C++中 string 类型可以直接用 == 判断两个字符串是否相等。（ ✓ 正确 ）

【答案：正确 ✓】 解析：

• C++的 string 类重载了比较运算符，可以直接比较字符串内容

• 支持的比较运算：

string s1 = "Red", s2 = "Army", s3 = "Red";

s1 == s3   // true（内容相同）
s1 != s2   // true（内容不同）
s1 <  s2   // true（按字典序比较）
s1 >= s2   // false

• ⚠️ 注意：C风格字符串（char数组）不能直接用==比较！

char a[] = "Hello";
char b[] = "Hello";
if (a == b) ...     // ❌ 错误！比较的是地址，不是内容
if (strcmp(a, b) == 0) ...  // ✅ 正确！用strcmp函数

• 这就是 string 比 char[] 更方便的地方之一！
  • string 可以直接用 ==, !=, <, > 等
  • 支持 + 拼接字符串
  • 自动管理内存，不用担心溢出
  • 有 .length(), .size(), .substr() 等便捷方法