2025年3月 GESP C++ 4级

关于下述代码，说法错误的是（ ）。

int multiply(int x, int y);
int main() {
    int a = 4;
    int b = 5;
    int result = multiply(a, b);
    std::cout << "The result is: " << result << std::endl;
    return 0;
}
int multiply(int x, int y) {
    return x * y;
}

执行下述代码将输出（ ）。

int x = 10;
void func() { int x = 20; std::cout << x; }
int main() {
    func();
    std::cout << x;
    return 0;
}

执行下述代码后，变量 $a$ 的值为（ ）。

int a = 10;
int* p = &a;
*p = 20;

以下哪种参数传递方式可以避免拷贝大型对象？

执行下述代码，将输出（ ）。

void swap(int a, int &b) {
    int temp = a;
    a = b;
    b = temp;
}
int main() {
    int x = 1, y = 2;
    swap(x, y);
    std::cout << x << y;
    return 0;
}

下面的描述中，（ ）正确定义一个名为 Person 的结构体并正确初始化了一个 Person 结构体的变量 $p$。

给定如下代码，

struct Person {
    std::string name;
    int age;
    struct Address {
        std::string street;
        std::string city;
    };
    Address address;
};

下面描述错误的是（ ）。

假设 int arr[2][3] = {{1,2,3},{4,5,6}};，则 arr[1][2] 的值是（ ）。

下面（ ）正确定义了二维数组。

小杨正在爬楼梯，需要爬 $n$ 阶才能到达楼顶。如果每次可以爬 $1$ 个或 $2$ 个台阶，下面代码采用递推算法来计算一共有多少种不同的方法可以爬到楼顶，则横线上应填写（ ）。

int f(int n) {
    if (n == 1 || n == 2)
        return n;
    int f1 = 1;
    int f2 = 2;
    int res = 0;
    for (int i = 3; i <= n; i++) {
        ________________________________ // 在此处填入代码
    }
    return res;
}

给定如下算法，其时间复杂度为（ ）。

bool f(int arr[], int n, int target) {
    for (int i = 0; i < (1 << n); i++) {
        int sum = 0;
        for (int j = 0; j < n; j++) {
            if (i & (1 << j)) {
                sum += arr[j];
            }
        }
        if (sum == target) return true;
    }
    return false;
}

下面关于排序稳定性的描述，正确的是（ ）。

对数组 arr[] = {5, 3, 8, 1} 进行升序排序，执行第一轮冒泡排序后数组 arr 中的内容为（ ）。

运行下面的代码，将出现（ ）。

double hmean(double a, double b) {
    if (a == -b)
        throw runtime_error("Runtime error occurred.");
    return 2.0 * a * b / (a + b);
}
int main() {
    double x = 10;
    double y = -10;
    try {
        int result = hmean(x, y);
        cout << "hmean: " << result << endl;
    }
    catch (const runtime_error& e) {
        cout << "Caught: " << e.what() << endl;
    } catch (...) {
        cout << "Caught an unknown exception." << endl;
    }
    return 0;
}

下面哪种方式不能实现将字符串 "Happy Spring!" 输出重定向到文件 log.txt（ ）。

函数是 C++ 中的核心概念，用于封装可重用的代码块。

在 C++ 中，函数的返回类型可以省略，默认为 int。

结构体的成员默认是 public 访问权限。

假设整数数组 arr[4] = {0, 1, 2, 3}; 的第一个元素在内存中的地址为 0x7ffee4065820，经过 int* p = arr; p += 1; 后，指针 p 的值是 $1$。

二维数组作为函数参数时，必须显式指定所有维度的大小。

递推是一种通过已知的初始值和递推公式，逐步求解目标值的算法。

考虑最坏情况下冒泡排序算法的时间复杂度，$n$ 为待排序数字的数目，则其递推关系式为 $T(n)=T(n-1)+(n-1)$，$T(1)=0$。

插入排序在最好情况（已有序）下的时间复杂度是 $O(n)$。

对数组 arr[]={4, 3, 1, 5, 2} 进行升序排序，执行第一轮选择排序后数组 arr 中的内容是 {1, 4, 3, 5, 2}。

未捕获异常会调用 std::terminate 终止程序。

试题名称：荒地开垦

时间限制：1.0 s | 内存限制：512.0 MB

题目描述

小杨有一大片荒地，可以表示为一个 $n$ 行 $m$ 列的网格图。

小杨想要开垦这块荒地，但荒地中一些位置存在杂物，对于一块不存在杂物的荒地，该荒地可以开垦当且仅当其上下左右四个方向相邻的格子均不存在杂物。

小杨可以选择至多一个位置，清除该位置的杂物，移除杂物后该位置变为荒地。小杨想知道在清除至多一个位置的杂物的情况下，最多能够开垦多少块荒地。

输入格式

第一行包含两个正整数 $n,m$，含义如题面所示。

之后 $n$ 行，每行包含一个长度为 $m$ 且仅包含字符 . 和 # 的字符串。如果为 .，代表该位置为荒地；如果为 #，代表该位置为杂物。

输出格式

输出一个整数，代表在清除至多一个位置的杂物的情况下，最多能够开垦的荒地块数。

样例输入 #1

3 5
.....
.#..#
.....

样例输出 #1

11

说明/提示

样例解释

移除第二行从左数第二块空地的杂物后：

.....
....#
.....

第一行从左数前 $4$ 块荒地，第二行从左数前 $3$ 块荒地，第三行从左数前 $4$ 块荒地，均可开垦，$4+3+4=11$。

数据范围

对于全部数据，有 $1\le n,m\le 1000$。

试题名称：二阶矩阵

时间限制：1.0 s | 内存限制：512.0 MB

题目描述

小 A 有一个 $n$ 行 $m$ 列的矩阵 $A$。

小 A 认为一个 $2\times 2$ 的矩阵 $D$ 是好的，当且仅当 D1,1×D2,2=D1,2×D2,1D_{1,1} \times D_{2,2} = D_{1,2} \times D_{2,1}D1,1​×D2,2​=D1,2​×D2,1​。其中 Di,jD_{i,j}Di,j​ 表示矩阵 $D$ 的第 $i$ 行第 $j$ 列的元素。

小 A 想知道 $A$ 中有多少个好的子矩阵。

输入格式

第一行，两个正整数 $n,m$。

接下来 $n$ 行，每行 $m$ 个整数 Ai,1,Ai,2,…,Ai,mA_{i,1}, A_{i,2}, \ldots, A_{i,m}Ai,1​,Ai,2​,…,Ai,m​。

输出格式

一行，一个整数，表示 $A$ 中好的子矩阵的数量。

样例输入 #1

3 4
1 2 1 0
2 4 2 1
0 3 3 0

样例输出 #1

2

说明/提示

样例解释

样例中好的子矩阵如下：

数据范围

对于所有测试点，保证 $1\le n\le 500$，$1\le m\le 500$，−100≤Ai,j≤100-100\leq A_{i,j}\leq 100−100≤Ai,j​≤100