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

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

1. 下列关于C++变量的叙述，正确的是（ C ）

A. 变量可以没有定义就直接使用     // ❌ 编译错误
B. 对未定义的变量赋值相当于定义了新变量  // ❌ 还是错误
C. 执行赋值语句后，变量的类型不会改变    // ✅ 正确
D. 变量名可以完全是数字           // ❌ 不合法

【答案：C】

• A. 变量可以没有定义就直接使用 ❌ 严重错误！ C++是静态类型语言，变量必须先声明后使用，否则编译错误
• B. 对未定义的变量赋值相当于定义了新变量 ❌ 错误！这不是Python或JavaScript，C++不允许这样
• C. 执行赋值语句后，变量的类型不会改变 ✅ 正确！C++中变量类型在编译时确定，运行时不能改变

  int a = 10;
  a = 3.14;   // a仍然是int类型，值被截断为3，类型不变
  

• D. 变量名可以完全是数字 ❌ 标识符规则：必须以字母或下划线开头

---

2. 红军记录行军温度（可能为 -15.5℃），应使用哪种变量类型？（ B ）

【答案：B】

• A. int ❌ 整型只能存储整数，无法存储小数 -15.5
• B. double ✅ 正确！双精度浮点型可以存储带小数的数值，包括负数

  double temperature = -15.5;  // 完美存储
  

• C. char ❌ 字符型只能存储单个字符（如'A'、'9'），不是用来存数字的
• D. bool ❌ 布尔型只有两个值：true 和 false

💡 何时用 double vs float？

• float：4字节，精度约6-7位有效数字
• double：8字节，精度约15-16位有效数字
• 一般科学计算、温度等推荐用 double

---

3. 关于 endl，以下说法正确的是（ B ）

cout << "Hello" << endl;  // 输出Hello并换行

【答案：B】

• A. endl 只能用在 cin 后面 ❌ 完全错误！endl 是输出流操纵符，用于 cout

• B. endl 的作用是换行 ✅ 正确！endl = end line（结束行），作用：

  1. 插入换行符 \n
  2. 刷新输出缓冲区（立即显示到屏幕）

• C. endl 和 "\n" 完全一样 ❌ 不完全一样！

  • 相同点：都会换行
  • 不同点：endl 会刷新缓冲区，\n 可能不会立即显示（性能更好但可能有延迟）

• D. 一个 cout 语句只能用一次 endl ❌ 可以多次使用

  cout << "A" << endl << "B" << endl;  // 完全合法
  

---

4. 红军仓库有子弹200发，分给7个战斗小组，以下哪个表达式可以算出剩余子弹数？（ B ）

200发子弹，每组28发（假设）
200 ÷ 7 = 28 余 4
余数就是剩余的子弹数

【答案：B】

• A. 200 / 7 ❌ 这是整数除法，结果为 28（商），表示每组能分到多少发
• B. 200 % 7 ✅ 正确！取模运算 % 返回余数，即剩余的子弹数
  • 200 % 7 = 4 （200 = 7×28 + 4）
• C. 200 - 7 ❌ 结果为193，无实际意义
• D. 200 * 7 ❌ 结果为1400，完全不对

💡 / 和 % 的区别：

• / (除法)：求商 → 每人能分多少
• % (取模)：求余数 → 还剩多少

---

5. pow(3, 4) 的结果是（ C ）

【答案：C】

• A. 7 ❌ 这是 3+4 的结果
• B. 12 ❌ 这是 3×4 的结果
• C. 81 ✅ 正确！pow(底数, 指数) 计算幂运算
  • pow(3, 4) = $3^4$ = 3 × 3 × 3 × 3 = 81
• D. 64 ❌ 这是 $2^6$ 或 $4^3$ 或 $8^2$ 的结果

💡 pow() 函数：

• 头文件：<cmath> 或 <math.h>
• 返回值类型：double
• 常见用法：
  • pow(2, 10) = 1024
  • pow(10, 3) = 1000
  • sqrt(x) = pow(x, 0.5) 开平方

---

6. 关于 if-else if-else 结构，以下说法正确的是（ B ）

【答案：B】

• A. 所有条件分支都会依次执行 ❌ 错误！这是互斥结构，只会执行一个分支
• B. 一旦某个条件满足，执行对应语句后跳出整个结构 ✅ 正确！这是核心特性
• C. else if 可以单独使用 ❌ 不能！else if 必须跟在 if 后面，不能独立存在
• D. else 分支必须存在 ❌ else 是可选的，可以没有

📝 if-else if-else 结构特点：

if (条件1) {
    // 条件1为真时执行
} else if (条件2) {     // 可有0个或多个else if
    // 条件2为真时执行
} else {                // 可选，最多1个
    // 所有条件都为假时执行
}

---

7. C++表达式 2 - 1 && 2 % 10 的值是（ B ）

逐步计算：
1. 2 - 1 = 1           // 算术运算优先
2. 2 % 10 = 2          // 取模运算
3. 1 && 2              // 逻辑与运算
   在C++中：非零值为true(1)，零为false(0)
   所以：true && true = true = 1

【答案：B】

• A. 0 ❌ 计算错误
• B. 1 ✅ 正确！最终结果是逻辑真，在C++中表示为1
• C. 2 ❌ 不是算术结果
• D. 3 ❌ 无此可能

💡 逻辑运算符的返回值：

• && (逻辑与)：两边都非零返回1（true），否则返回0（false）
• || (逻辑或)：任一边非零返回1，否则返回0
• ! (逻辑非)：非零变0，零变1

---

8. for循环输出（ B ）

for (int i = 1; i <= 4; i *= 2) {
    cout << i << " ";
}
// 执行过程：
// i=1:  1<=4 ✓, 输出1,  i=1*2=2
// i=2:  2<=4 ✓, 输出2,  i=2*2=4
// i=4:  4<=4 ✓, 输出4,  i=4*2=8
// i=8:  8<=4 ✗, 退出
// 输出结果: 1 2 4

【答案：B】

• A. 1 2 3 4 ❌ 这是 i++ 的结果，这里是 i *= 2（每次翻倍）
• B. 1 2 4 ✅ 正确！i 取值：1 → 2 → 4 → 8(退出)，输出 1 2 4
• C. 1 2 4 8 ❌ i=8 时不满足 i<=4，不会输出
• D. 无限循环 ❌ i 不断翻倍增长，最终会超过4退出

---

9. while循环求和（ C ）

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

【答案：C】

• A. 4 ❌ 只是最后一次i的值
• B. 6 ❌ 这是1+2+3的结果
• C. 10 ✅ 正确！1 + 2 + 3 + 4 = 10
• D. 无限循环 ❌ 有明确的终止条件 i<=4

---

10. 以下哪个是C++中合法的 do-while 循环？（ A ）

【答案：A】

• A. do { cout << 1; } while (true); ✅ 正确！do-while语法：

  do {
      循环体语句;
  } while (条件);   // 注意分号！
  

• B. do cout << 1; while (true) ❌ 缺少花括号且末尾缺少分号
• C. do (cout << 1) while (true); ❌ 多余的括号
• D. while do { cout << 1; }; ❌ 语法完全错误，顺序颠倒了

⚠️ do-while vs while 的关键区别：

• while：先判断后执行（可能0次）
• do-while：先执行后判断（至少1次）

---

11. 字符类型转换（ B ）

char c = char(65);
cout << c << endl;
// ASCII码：65 = 'A'（大写字母A）
// char(65) 将整数65转换为对应ASCII字符
// 输出: A

【答案：B】

• A. 65 ❌ 如果c是int类型才会输出65
• B. A ✅ 正确！char类型输出的是字符本身，ASCII码65对应大写字母 'A'
• C. a ❌ 小写a的ASCII码是97
• D. 编译错误 ❌ 合法操作

💡 常用ASCII码：

• '0'-'9': 48-57
• 'A'-'Z': 65-90
• 'a'-'z': 97-122
• char(65) = 'A', char(97) = 'a'

---

12. 多分支选择结构（ A ）

int phase = 1;  // 1=侦察
if (phase == 1) {           // phase==1? Yes!
    cout << "侦察敌情";      // ← 执行这个
} else if (phase == 2) {     // 跳过
    cout << "发起突击";
} else {                    // 跳过
    cout << "安全撤退";
}

【答案：A】

• A. 侦察敌情 ✅ 正确！phase=1，匹配第一个条件
• B. 发起突击 ❌ 需要 phase==2
• C. 安全撤退 ❌ 需要phase既不等于1也不等于2
• D. 侦察敌情发起突击 ❌ 只会执行一个分支

---

13. switch语句（ C ）

int signal = 3;
switch (signal) {
    case 1: cout << "烽火"; break;
    case 2: cout << "骑马"; break;
    case 3: cout << "电报"; break;  // 匹配！输出"电报"
    default: cout << "其他"; break;
}

【答案：C】

• A. 烽火 ❌ signal=1才执行
• B. 骑马 ❌ signal=2才执行
• C. 电报 ✅ 正确！case 3: 匹配 signal=3，输出"电报"，然后break退出
• D. 其他 ❌ 只有所有case都不匹配时才执行default

---

14. 关于C++一维数组，以下说法正确的是（ B ）

【答案：B】

• A. 数组下标从 1 开始 ❌ 严重错误！ C++数组下标从 0 开始
• B. int arr[5] 的有效下标范围是 0~4 ✅ 正确！定义了5个元素，下标0,1,2,3,4
• C. 数组大小可以在运行时随意改变 ❌ C++原生数组大小在编译时固定，不能动态改变（要用vector才行）
• D. arr[5] 是合法的数组访问 ❌ 越界访问！ arr[5]是第6个元素，但数组只有5个（0-4），这是未定义行为！

⚠️ 数组越界的危险：

int arr[5] = {1,2,3,4,5};
cout << arr[5];   // 越界！可能输出垃圾值或崩溃
cout << arr[-1];  // 负数下标也是越界！

---

15. 函数定义和调用（ B ）

【答案：B】

• A. int add(int a, b) { return a + b; } ❌ 参数列表中每个参数都要单独声明类型
• B. int add(int a, int b) { return a + b; } ✅ 正确！标准函数定义格式：

  返回类型 函数名(参数类型 参数名, ...) {
      函数体;
      return 返回值;
  }
  

• C. int add(a, b) { return a + b; } ❌ 缺少参数类型声明（C++不是弱类型语言）
• D. add(int a, int b) { return a + b; } ❌ 缺少返回类型！

💡 函数三要素：

1. 返回类型：int, void, double等
2. 函数名：标识符
3. 参数列表：每个参数都要有类型和名称

---

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

---

16. 在C++中，程序按照代码书写顺序从上到下依次执行，这是顺序结构的特征。（ ✓ 正确 ）

【答案：正确 ✓】 解析：

• 三种基本程序结构：

  1. 顺序结构：语句按书写顺序从上到下、从左到右依次执行

     int a = 10;        // 第1步
     int b = 20;        // 第2步
     int c = a + b;     // 第3步（依赖前两步的结果）
     

  2. 选择结构：根据条件选择执行不同分支（if-else, switch）
  3. 循环结构：重复执行某段代码（for, while, do-while）

• 顺序结构是最基本的结构，所有程序都包含顺序执行的部分

---

17. 循环嵌套中，外层循环每执行一次，内层循环完整执行一遍。（ ✓ 正确 ）

【答案：正确 ✓】 解析：

• 嵌套循环执行规律：

for (外层 i = 0; i < M; i++) {      // 外层执行M次
    for (内层 j = 0; j < N; j++) {  // 每次外层循环，内层完整执行N次
        // 内层循环体
    }
}
总执行次数 = M × N

• 示例：

for (int i = 0; i < 3; i++) {      // 外层3次
    for (int j = 0; j < 4; j++) {  // 内层每次都完整执行4次
        cout << "* ";
    }
    cout << endl;
}
// 输出3行，每行4个*，总共12个*

• 这就像时钟：时针走1格，分针转1圈；时针走M格，分针转M圈

---

18. 模拟法就是按照题目描述的过程，一步步用代码"模仿"出来。（ ✓ 正确 ）

【答案：正确 ✓】 解析：

• 模拟法（Simulation） 是信息学竞赛中的基础算法思想

• 核心思想： 不需要巧妙的算法优化，直接按照题目描述的过程，用代码原样模拟即可

• 适用场景：

  • 过程明确、步骤清晰的问题
  • 数据规模较小的情况
  • 题目本身就是描述一个过程

• 示例：模拟掷骰子100次，统计各点出现次数

int count[7] = {0};  // 1-6点的计数器
for (int i = 0; i < 100; i++) {
    int dice = rand() % 6 + 1;  // 模拟掷骰子
    count[dice]++;               // 统计
}

• 优点： 思路简单直接，不易出错
• 缺点： 效率可能不高，适合小规模数据

---

19. 表达式 6 & 3 的值是2。（ ✓ 正确 ）

【答案：正确 ✓】 解析：

• & 是按位与（Bitwise AND）运算符

• 运算规则：对两个数的每一位进行与运算

  • 1 & 1 = 1
  • 1 & 0 = 0
  • 0 & 1 = 0
  • 0 & 0 = 0

• 计算过程：

  6 的二进制:  0110
  3 的二进制:  0011
  -------------
  按位与结果:   0010  =  十进制的 2

• 验证： 0110 & 0011 = 0010 = 2 ✅

💡 位运算常见用途：

• 判断奇偶：n & 1 （结果为1是奇数，0是偶数）
• 取特定位：num & mask
• 快速运算：n * 2 等价于 n << 1

---

20. 选择排序每一轮从未排序部分选出最小的元素，放到已排序部分的末尾。（ ✓ 正确 ）

【答案：正确 ✓】 解析：

• 选择排序（Selection Sort）原理：

  每一轮从未排序的元素中选出最小（或最大）的一个， 与未排序部分的第一个元素交换位置

• 示例（升序排列 [5,3,8,1,2]）：

初始:   [5, 3, 8, 1, 2]
第1轮:  找最小=1，与第1个交换 → [**1**, 3, 8, 5, 2]
第2轮:  从[3,8,5,2]找最小=2，与第2个交换 → [1, **2**, 8, 5, 3]
第3轮:  从[8,5,3]找最小=3，与第3个交换 → [1, 2, **3**, 5, 8]
第4轮:  从[5,8]找最小=5，已到位 → [1, 2, 3, **5**, 8]
结果:   [1, 2, 3, 5, 8]  ✓ 排序完成

• 与冒泡排序的区别： | 特征 | 选择排序 | 冒泡排序 | |------|---------|---------| | 操作 | 选出最小/大，交换一次 | 相邻比较，可能多次交换 | | 交换次数 | 最多 n-1 次 | 可能很多次 | | 时间复杂度 | O(n²) | O(n²) | | 稳定性 | ❌ 不稳定 | ✅ 稳定 |