GESP 四级 · 2024 真题

在 C++ 中，（ ）正确定义了一个返回整数值并接受两个整数参数的函数。

在 C++ 中，形参与实参的关系描述正确的是（ ）。

运行以下代码，屏幕上将输出（ ）。

01#include <iostream>
02using namespace std;
03
04int var = 100;
05
06void function() {
07    int var = 200;
08
09    cout << var << " ";
10    cout << ::var << " ";
11}
12
13int main() {
14    cout << var << " ";
15
16    function();
17
18    var += 100;
19    cout << var << " ";
20
21    return 0;
22}

运行下面代码，屏幕上输出是（ ）。

01int arr[3] = {24, 9, 7};
02int* p = arr;
03p++;
04cout << *p << endl;

运行下面代码片段的结果是（ ）。

01int x = 20;
02int y = 24;
03int* p = &x;
04int* q = &y;
05
06p = q;

在 C++ 中，（ ）正确定义一个名为 student 的结构体，其中包含一个 name 字符数组和一个 age 整数？

在 C++ 中，（ ）正确声明了一个 $3$ 行 $4$ 列的二维数组。

一个二维数组定义为 int arr[3][4];（假设一个 int 变量占 $4$ 个字节），则 int arr[0] 占用（ ）个字节的内存。

下面代码采用递推算法来实现整数 $n$ 的阶乘（$n! = n \times (n-1) \times \ldots \times 2 \times 1$），则横线上应填写（ ）。

01int factorial(int n) {
02    int result = 1;
03    for (int i = 2; i <= n; i++) {
04        ____________  // 在此处填入代码
05    }
06    return result;
07}

在排序算法中，稳定性指的是（ ）。

下面代码实现了冒泡排序函数，则横线上应填写（ ）。

01//交换数组arr的第i个元素和第j个元素
02void swap(vector<int> &arr, int i, int j) {
03    int tmp = arr[i];
04    arr[i] = arr[j];
05    arr[j] = tmp;
06}
07
08int bubble_sort(vector<int> &arr) {
09    for (int i = arr.size() - 1; i > 0; i--) {
10        bool flag = false; // 标志位
11        ____________{    // 在此处填入代码
12            if(arr[j] > arr[j + 1]) {
13                swap(arr, i, j);
14                flag = true;
15            }
16        }
17        if(!flag)
18            break; // 此轮"冒泡"未交换任何元素
19    }
20}
21

冒泡排序算法在最坏情况下的时间复杂度为（ ）。

下面代码实现了插入排序函数（升序），则横线上应填写（ ）。

01void insertion_sort(vector<int> &nums) {
02    for (int i = 1; i < nums.size(); i++) {
03        int base = nums[i], j = i - 1;
04
05        ____________{    // 在此处填入代码
06            nums[j + 1] = nums[j];
07            j--;
08        }
09        nums[j + 1] = base;
10    }
11}

小杨用文件重定向实现在 log.txt 文件中输出日志，则下面横线上应填写（ ）。

01#include <iostream>
02#include <fstream>
03#include <string>
04using namespace std;
05
06int main() {
07    ofstream log_file("log.txt");
08
09    streambuf* original_cout = cout.rdbuf();
10    cout.rdbuf(log_file.rdbuf());
11
12    ____________{    // 在此处填入代码
13
14    cout.rdbuf(original_cout);  // 恢复原始的标准输出缓冲区
15    return 0;
16}

运行下面的代码，屏幕上将输出（ ）。

01#include <iostream>
02using namespace std;
03
04int divide(int a, int b) {
05    if (b == 0) {
06        throw runtime_error("division by zero error ");
07    }
08    return a / b;
09}
10
11int main() {
12    int x = 10;
13    int y = 0;  // 设为 0 会导致除零错误
14
15    try {
16        int result = divide(x, y);
17        cout << "result: " << result <<endl;
18    }catch (const runtime_error& e) {
19        cout << "caught an exception: " << e.what() << endl;
20    }
21
22    return 0;
23}

代码 int a = 10; int* p = &a; 可以正确定义指针和初始化指针。

在 C++ 中，引用传递允许函数修改传递给它的参数的值。

指针的大小与其所指向的变量的数据类型的大小相同。

二维数组的行的大小的必须在定义时确定，列的大小可以动态变化。

递推算法通过逐步求解当前状态和前一个或几个状态之间的关系来解决问题。

选择排序是稳定的排序算法。

插入排序的时间复杂度总是比冒泡排序低。

在 C++ 中，如果没有捕获到异常（没有匹配的 catch 块），程序会继续执行而不会终止。

以下代码用递推法求斐波那契数列的第 $n$ 项，时间复杂度为指数级。

01int fibonacci(int n) {
02    if (n == 0) return 0;
03    if (n == 1) return 1;
04
05    int f0 = 0; // F(0)
06    int f1 = 1; // F(1)
07    int current;
08
09    for (int i = 2; i <= n; i++) {
10        current = f0 + f1; // F(n) = F(n-1) + F(n-2)
11        f0 = f1;
12        f1 = current;
13    }
14
15    return current;
16}

执行下面 C++ 代码后，输出的是 $20$。

01int point(int* p){
02    return *p * 2;
03}
04
05int main() {
06    int a = 10;
07    int* p = &a;
08    *p = point(p);
09    cout << *p << endl;
10}