GESP C++ 四 级 2025年9月真题（120 分钟，总分 100 分）

单选题（共 15 题，每题 2 分，共 30 分）

1. 运行下面程序后变量a的值是（   ）。

int a = 42;
int* p = &a;
*p = *p + 1;

{{ select(1) }}

• 42
• 43
• 编译错误
• 不确定

2. 以下关于数组的描述中，（   ）是错误的。

{{ select(2) }}

• 数组名是一个指针常量
• 随机访问数组的元素方便快捷
• 数组可以像指针一样进行自增操作
• sizeof(arr) 返回的是整个数组arr占用的字节数

3. 给定如下定义的数组arr，则*(*(arr + 1) + 2)的值是（   ）。

int arr[2][3] = {{1, 2, 3}, {4, 5, 6}};

{{ select(3) }}

• 2
• 5
• 4
• 6

4. 下面这段代码会输出（   ）。

int add(int a, int b = 1); // 函数声明

int main() {
   cout << add(2) << " " << add(2, 3);
   return 0;
}

int add(int a, int b) { // 函数定义
   return a + b;
}

{{ select(4) }}

• 3 5
• 编译失败：定义处少了默认参数
• 运行错误
• 链接失败：未定义引用

5. 下面这段代码会输出（   ）。

int x = 5;

void foo() {
   int x = 10;
   cout << x << " ";
}

void bar() {
   cout << x << " ";
}

int main() {
   foo();
   bar();
}

{{ select(5) }}

• 5 5
• 10 10
• 5 10
• 10 5

6. 下面程序运行的结果是（   ）。

void increaseA(int x) {
   x++;
}
void increaseB(int* p) {
  (*p)++;
}
int main() {
   int a = 5;
   increaseA(a);
   cout << a << " ";
   increaseB(&a);
   cout << a;
}

{{ select(6) }}

• 6 7
• 6 6
• 5 6
• 5 5

7. 关于结构体初始化，以下哪个选项中正确的是（   ）。

struct Point {int x,y;};

{{ select(7) }}

• Point p = (1,2);
• Point p = {1,2};
• Point p = new {1,2};
• Point p = <1,2>;

8. 运行如下代码会输出（  ）。

struct Cat {
   string name;
   int age;
};

void birthday(Cat& c) {
   c.age++;
}

int main() {
   Cat kitty{"Mimi", 2};
   birthday(kitty);
   cout << kitty.name << " " << kitty.age;
}

{{ select(8) }}

• Mimi 2
• Mimi 3
• kitty 3
• kitty 2

9. 关于排序算法的稳定性，以下说法错误的是（   ）。

{{ select(9) }}

• 稳定的排序算法不改变相等元素的相对位置
• 冒泡排序是稳定的排序算法
• 选择排序是稳定的排序算法
• 插入排序是稳定的排序算法

10. 下面代码试图实现选择排序，使其能对数组 nums 排序为升序，则横线上应分别填写（   ）。

void selectionSort(vector<int>& nums) {
   int n = nums.size();
   for (int i = 0; i < n - 1; ++i) {
       int minIndex = i;
       for (int j = i + 1; j < n; ++j) {
           if ( __________ ) {     // 在此处填入代码
               minIndex = j;
          }
      }
      ____________________; // 在此处填入代码
   }
}

{{ select(10) }}

• nums[j] < nums[minIndex]
swap(nums[i], nums[minIndex])
• nums[j] > nums[minIndex]
swap(nums[i], nums[minIndex])
• nums[j] <= nums[minIndex]
swap(nums[j], nums[minIndex])
• nums[j] <= nums[minIndex]
swap(nums[i], nums[j])

11. 下面程序实现插入排序（升序排序），则横线上应分别填写（   ）。

void insertionSort(int arr[], int n) {
   for (int i = 1; i < n; i++) {
       int key = arr[i];
       int j = i - 1;
       while ( j >= 0 && ____________________ ) { // 在此处填入代码
           arr[j + 1] = arr[j];
           j--;
      }
       ____________________; // 在此处填入代码
   }
}

{{ select(11) }}

• arr[j] > key
arr[j + 1] = key
• arr[j] < key
arr[j + 1] = key
• arr[j] > key
arr[j] = key
• arr[j] < key
arr[j] = key

12. 关于插入排序的时间复杂度，下列说法正确的是（   ）。

{{ select(12) }}

• 最好情况和最坏情况的时间复杂度都是  O(n²)
• 最好情况是 O(n)，最坏情况是  O(n²)
• 最好情况是 O(n)，最坏情况是 O(2ⁿ)
• 最好情况是 O(n²)，最坏情况是 O(2ⁿ)

13. 小杨正在爬楼梯，需要  n 阶才能到达楼顶，每次可以爬 1 阶或 2 阶，求小杨有多少种不同的方法可以爬到楼顶，横线上应填写（  ）。

int climbStairs(int n) {
   if (n <= 2) return n;
   int prev2 = 1;
   int prev1 = 2;
   int current = 0;
   for (int i = 3; i <= n; ++i) {
       ________________    // 在此处填入代码
       
   }
   return current;
}

{{ select(13) }}

• prev2 = prev1;
prev1 = current;
current = prev1 + prev2;
• current = prev1 + prev2;
prev2 = prev1;
prev1 = current;
• current = prev1 + prev2;
prev1 = current;
prev2 = prev1;
• prev1 = current;
prev2 = prev1;
current = prev1 + prev2;

14. 假设有一个班级的成绩单，存储在一个长度为 n 的数组 scores 中，每个元素是一个学生的分数。老师想要找出 所有满足 scores[i] + scores[j] + scores[k] == 300 的三元组，其中 i < j < k。下面代码实现该功能，请问其时间复杂度是（   ）。

int cnt = 0;
for (int i = 0; i < n; i++) {
   for (int j = i + 1; j < n; j++) {
       for (int k = j + 1; k < n; k++) {
           if (scores[i] + scores[j] + scores[k] == 300) {
               cnt++;
          }
      }
   }
}

{{ select(14) }}

• O(n)
• O(n²)
• O(n³)
• O(2ⁿ)

15. 关于异常处理，以下说法错误的是（   ）。

{{ select(15) }}

• try 块中的代码可能会抛出异常
• catch 块可以有多个，处理不同类型的异常
• throw 语句用于抛出异常
• 所有异常都必须被捕获，否则程序会崩溃