5619：[GESP202609四级] 客观题
文件提交：无需freopen
内存限制：128 MB
时间限制：1.000 S
评测方式：文本裁判
金币值：
命题人：
提交：0
解决：0
题目描述
## 一、单选题（每题 2 分，共 30 分）
**第 1 题** 小杨使用指针修改计数器的值。执行下面程序后，输出结果是（ ）
```cpp
01 int count = 8;
02 int *p = &count;
03 *p += 4;
04 cout << count << " " << *p;
05 return 0;
```
- `8 8`
- `8 12`
- `12 12`
- `12 8`
**第 2 题** 关于下面指针声明的说法，正确的是（ ）
```cpp
01 int a = 10;
02 int b = 20;
03 const int *p = &a;
```
- 可以通过 $p$ 修改 $a$ 的值
- 可以令 $p = &b$
- $p$ 的指向和所指向的值都不能修改
- $p$ 必须始终指向 $a$
**第 3 题** 小杨用二维数组记录仓库货物数量。执行下面代码后，变量 `x` 的值是（ ）
```cpp
01 int goods[3][4] = {{2, 4, 6, 8}, {10, 12, 14, 16}, {18, 20, 22, 24}};
02 int (*p)[4] = goods;
03 int x = *(*(p + 1) + 2);
```
- $12$
- $14$
- $20$
- $22$
**第 4 题** 下面函数用于将一个 $3$ 行 $5$ 列二维数组的第 $r$ 行元素全部加 $1$，横线处正确的形参写法是（ ）
```cpp
01 void addOne(________, int r) {
02 for (int j = 0; j < 5; j++) {
03 arr[r][j]++;
04 }
05 }
```
- `int arr[][]`
- `int **arr`
- `int arr[][5]`
- `int arr[5][]`
**第 5 题** 执行下面程序后，输出结果是（ ）
```cpp
01 int score = 60;
02
03 void update(int &score) {
04 score += 5;
05 }
06
07 int main() {
08 int score = 80;
09 update(score);
10 cout << score << " " << ::score;
11 return 0;
12 }
```
- `85 60`
- `80 65`
- `85 65`
- `80 60`
**第 6 题** 执行下面程序后，输出结果是（ ）
```cpp
01 struct Device {
02 int id;
03 int state;
04 };
05
06 void reset(Device d) {
07 d.state = 0;
08 }
09
10 void start(Device &d) {
11 d.state += 1;
12 }
13
14 int main() {
15 Device d{7, 2};
16 reset(d);
17 start(d);
18 cout << d.id << " " << d.state;
19 return 0;
20 }
```
- `7 0`
- `7 1`
- `7 2`
- `7 3`
**第 7 题** 小杨定义了结构体数组，并使用指针访问其中的元素。执行下面代码后输出的是（ ）
```cpp
01 struct Book {
02 string name;
03 int pages;
04 };
05
06 int main() {
07 Book books[2] = {{"C++", 120}, {"Math", 150}};
08 Book *p = books + 1;
09 p->pages += 10;
10 cout << books[1].name << " " << books[1].pages;
11 return 0;
12 }
```
- `C++ 120`
- `Math 150`
- `Math 160`
- `C++ 160`
**第 8 题** 关于冒泡排序、插入排序和选择排序，下列说法正确的是（ ）
- 三种排序算法的最坏时间复杂度都是 $O(n)$
- 冒泡排序只能从小到大排序，不能从大到小排序
- 插入排序每次将一个待排序元素插入前面已经有序的序列中
- 选择排序每轮只需要比较一次就能确定最小元素
**第 9 题** 某机器人每次可以向前移动 $1$ 格或 $2$ 格，到达第 $n$ 格的方法数由下面函数计算。`ways(6)` 的返回值是（ ）
```cpp
01 int ways(int n) {
02 if (n <= 2)
03 return n;
04 int a = 1, b = 2, c = 0;
05 for (int i = 3; i <= n; i++) {
06 c = a + b;
07 a = b;
08 b = c;
09 }
10 return b;
11 }
```
- $8$
- $10$
- $13$
- $21$
**第 10 题** 对一组 `struct student` 的学生按成绩（`score`）升序排序。排序前后的数据如下。关于该排序的稳定性，判断正确的是（ ）
```cpp
01 struct student {
02 int score;
03 char id;
04 };
```
```text
排序前：
(90, 'A'), (80, 'B'), (90, 'C'), (80, 'D')
```
排序后：
```
(80, 'B'), (80, 'D'), (90, 'C'), (90, 'A')
```
- 稳定，因为所有成绩已经按升序排列
- 稳定，因为分数相同不会影响排序结果
- 不稳定，因为相同成绩的 ($90$, $'A'$) 和 ($90$, $'C'$) 的相对顺序发生了改变
- 无法判断，因为没有给出排序算法的代码
**第 11 题** 下面代码使用插入排序将数组按升序排列，横线处应填写（ ）
```cpp
01 void insertionSort(int a[], int n) {
02 for (int i = 1; i < n; i++) {
03 int key = a[i];
04 int j = i - 1;
05 while (j >= 0 && __________) {
06 a[j + 1] = a[j];
07 j--;
08 }
09 a[j + 1] = key;
10 }
11 }
```
- `a[j] < key`
- `a[j] > key`
- `a[j] == key`
- `a[j + 1] > key`
**第 12 题** 下面代码的时间复杂度是（ ）。
```cpp
01 int countPairs(int a[], int n) {
02 int cnt = 0;
03 for (int i = 0; i < n; i++) {
04 for (int j = i + 1; j < n; j++) {
05 if (a[i] + a[j] == 100) {
06 cnt++;
07 }
08 }
09 }
10 return cnt;
11 }
```
- $O(1)$
- $O(n^3)$
- $O(n)$
- $O(n^2)$
**第 13 题** 假设文件 `data.txt` 的内容如下：
```text
Blue Sky
```
执行下面程序后，输出结果是（ ）
```cpp
01 int main() {
02 ifstream fin("data.txt");
03 string a, b;
04 fin >> a >> b;
05 cout << b << "-" << a;
06 fin.close();
07 return 0;
08 }
```
- `Blue-Sky`
- `Sky-Blue`
- `Blue Sky`
- `Sky Blue`
**第 14 题** 执行下面程序后，输出结果是（ ）
```cpp
01 int main() {
02 try {
03 int age = -1;
04 if (age < 0)
05 throw age;
06 cout << "A";
07 } catch (const char *msg) {
08 cout << "B";
09 } catch (int value) {
10 cout << "C" << value;
11 }
12 return 0;
13 }
```
- `A`
- `B`
- `C-1`
- 程序崩溃
**第 15 题** 下面函数使用冒泡排序将数组按升序排列。为了在数组已经有序时提前结束，两处横线应分别填写（ ）
```cpp
01 void bubbleSort(int a[], int n) {
02 for (int i = n - 1; i > 0; i--) {
03 bool changed = __________;
04 for (int j = 0; j < i; j++) {
05 if (a[j] > a[j + 1]) {
06 int t = a[j];
07 a[j] = a[j + 1];
08 a[j + 1] = t;
09 changed = __________;
10 }
11 }
12 if (!changed)
13 break;
14 }
15 }
```
- `false ，true`
- `true ，false`
- `false ，false`
- `true ，true`
## 二、判断题（每题 2 分，共 20 分）
**第 1 题** 执行下面程序后，变量 `a` 的值为 $15$。
```cpp
01 int a = 10;
02 int *p = &a;
03 *p += 5;
```
- 正确
- 错误
**第 2 题** 一个函数必须在调用之前既声明又定义。
- 正确
- 错误
**第 3 题** 下面二维数组在内存中按行优先连续存储，因此 `*(*(a + 1) + 0)` 的值为 $5$ 。
```cpp
01 int a[2][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}};
```
- 正确
- 错误
**第 4 题** 执行下面程序后会输出 $20$。
```cpp
01 void change(int x) {
02 x = 20;
03 }
04
05 int main() {
06 int x = 10;
07 change(x);
08 cout << x;
09 return 0;
10 }
```
- 正确
- 错误
**第 5 题** 下面结构体初始化语句是合法的。
```cpp
01 struct Point {
02 int x;
03 int y;
04 };
05
06 Point p{3, 4};
```
- 正确
- 错误
**第 6 题** 对于按升序实现的稳定插入排序，移动元素的条件通常应为 `a[j] >= key`，这样能够保证相等元素的相对顺序不变。
```cpp
01 while (j >= 0 && a[j] >= key) {
02 a[j + 1] = a[j];
03 j--;
04 }
```
- 正确
- 错误
**第 7 题** 下面递推程序计算。当 `n = 4` 时，返回值为 $24$。
```cpp
01 int factorial(int n) {
02 int result = 1;
03 for (int i = 1; i <= n; i++) {
04 result *= i;
05 }
06 return result;
07 }
```
- 正确
- 错误
**第 8 题** 下面两层循环的时间复杂度是 $O(n^2)$。
```cpp
01 for (int i = 0; i < n; i++) {
02 for (int j = 1; j < n; j *= 2) {
03 cout << i + j;
04 }
05 }
```
- 正确
- 错误
**第 9 题** 假设文件能够正常打开，下面程序会把 `Welcome` 写入 `log.txt`。
```cpp
01 int main() {
02 ofstream fout("log.txt");
03 fout << "Welcome";
04 fout.close();
05 return 0;
06 }
```
- 正确
- 错误
**第 10 题** 执行下面程序时，`catch (int e)` 能够捕获由 `throw "Error"` 抛出的异常，因此程序输出 `Caught`。
```cpp
01 int main() {
02 try {
03 throw "Error";
04 } catch (int e) {
05 cout << "Caught";
06 }
07 return 0;
08 }
```
- 正确
- 错误