本卷共 50 题：单项选择题 30 题（每题 2 分）、多项选择题 10 题（每题 3 分）、判断题 10 题（每题 1 分），满分 100 分。

一、单项选择题（每题 2 分）

1. 小华想用指针 ptr 指向整数变量 num，下列写法正确的是（ ）。

{{ select(1) }}

• int ptr = #
• int* ptr = num;
• int* ptr = #
• ptr = *num;

2. 执行下面代码后，变量 x 和 *p1 的值分别是（ ）。

int x = 8;
int* p1 = &x;
int* p2 = p1;
*p2 = 15;

{{ select(2) }}

• 8 8
• 8 15
• 15 15
• 15 8

3. 小丽用一个二维数组记录图书借阅状态，1 表示已借出，0 表示在架。她想判断第 3 行第 4 列的书是否在架，正确的代码是（ ）。

int book[4][5] = {
    {1,0,1,0,1},
    {0,1,0,1,0},
    {1,1,0,0,1},
    {0,0,1,1,0}
};

{{ select(3) }}

• cout << book[3,4];
• cout << book[3][4];
• cout << book(3,4);
• cout << book{3}{4};

4. 执行下面代码后，*(ptr + 4) 和 grid[1][1] 的值分别是（ ）。

int grid[3][4] = {
    {1,2,3,4},
    {5,6,7,8},
    {9,10,11,12}
};
int* ptr = &grid[0][0];

{{ select(4) }}

• 5 6
• 6 5
• 5 5
• 6 6

5. 执行下面代码后，sum 的值是（ ）。

int data[2][3][2] = {
    {{1,2},{3,4},{5,6}},
    {{7,8},{9,10},{11,12}}
};
int sum = 0;
for(int i = 0; i < 2; i++)
    for(int j = 0; j < 3; j++)
        for(int k = 0; k < 2; k++)
            if((i + j + k) % 2 == 1)
                sum += data[i][j][k];

{{ select(5) }}

• 36
• 39
• 42
• 78

6. 执行下面代码后，输出是（ ）。

int a = 2;
void func() {
    int a = 3;
    {
        int a = 4;
        a++;
    }
    a++;
    cout << a << " ";
}
int main() {
    func();
    cout << a;
    return 0;
}

{{ select(6) }}

• 4 2
• 5 2
• 4 3
• 5 3

7. 执行下面代码后，a、b、c 的值分别是（ ）。

void passByValue(int x) { x = 50; }
void passByRef(int& x) { x = 60; }
void passByPtr(int* x) { *x = 70; }

int main() {
    int a = 1, b = 2, c = 3;
    passByValue(a);
    passByRef(b);
    passByPtr(&c);
    return 0;
}

{{ select(7) }}

• 50 60 70
• 1 60 70
• 1 2 70
• 1 60 3

8. 执行下面代码后，输出为（ ）。

int main() {
    int a = 3, b = 5;
    int* p = &a;
    *p = 7;
    cout << a + b;
    return 0;
}

{{ select(8) }}

• 8
• 10
• 12
• 15

9. 给定函数 countWays(int n) 的定义如下，则 countWays(6) 的返回值是（ ）。

int countWays(int n) {
    if(n <= 2) return n;
    int a = 1, b = 2;
    for(int i = 3; i <= n; i++) {
        int tmp = a + b;
        a = b;
        b = tmp;
    }
    return b;
}

{{ select(9) }}

• 8
• 10
• 13
• 21

10. 对如下商品按价格（price）升序排序：

struct Product {
    int price;
    char id;
};
Product products[4] = {{30,'A'}, {20,'B'}, {30,'C'}, {20,'D'}};

排序后结果为：{20,'D'}, {20,'B'}, {30,'A'}, {30,'C'}。该排序算法是否稳定？

{{ select(10) }}

• 稳定，因为相同 price 的元素相对顺序保持不变
• 不稳定，因为 {20,'D'} 出现在 {20,'B'} 之前
• 无法判断
• 稳定，因为结果已经有序

11. 下面的函数 getTopThree() 用于从 n 个学生中找出分数最高的前 3 名，横线处应填写（ ）。

struct Student {
    string name;
    int score;
};
void getTopThree(Student stu[], int n) {
    for(int i = 0; i < 3; i++) {
        int maxIdx = i;
        for(______) {
            if(stu[j].score > stu[maxIdx].score) {
                maxIdx = j;
            }
        }
        if(maxIdx != i) {
            Student tmp = stu[i];
            stu[i] = stu[maxIdx];
            stu[maxIdx] = tmp;
        }
    }
}

{{ select(11) }}

• int j = 0; j < n; j++
• int j = i + 1; j < n; j++
• int j = i; j < n; j++
• int j = 1; j <= n; j++

12. 执行下面代码后，输出为（ ）。

int main() {
    int arr[5] = {2, 4, 6, 8, 10};
    int* p = arr;
    cout << p[2];
    return 0;
}

{{ select(12) }}

• 2
• 4
• 6
• 8

13. 执行下面代码后，输出为（ ）。

int main() {
    int a = 10;
    int& r = a;
    r = 20;
    cout << a;
    return 0;
}

{{ select(13) }}

• 10
• 15
• 20
• 25

14. 执行下面程序，输出结果是（ ）。

int divideNum(int a, int b) {
    if(b == 0) throw "Cannot divide by zero";
    return a / b;
}
int main() {
    int result = 0;
    try {
        result = divideNum(8, 0);
        cout << "A";
    } catch(const char* msg) {
        cout << "B";
        result = -1;
    }
    cout << result;
    return 0;
}

{{ select(14) }}

• A0
• B-1
• A8
• 程序崩溃

15. 关于递推算法，下列说法正确的是（ ）。

{{ select(15) }}

• 递推必须用递归函数实现
• 递推是从已知条件出发，按递推关系逐步求解
• 递推只能解决指数级复杂度的问题
• 递推算法一定需要回溯

16. 执行下面代码后，输出为（ ）。

int main() {
    int nums[5] = {10, 20, 30, 40, 50};
    int* p = nums;
    p = p + 2;
    cout << *p;
    return 0;
}

{{ select(16) }}

• 10
• 20
• 30
• 40

17. 已知：

int score[3][3] = {
    {70,75,80},
    {85,90,95},
    {100,105,110}
};
int (*p)[3] = score;

则表达式 *(*(p + 1) + 2) 的值为（ ）。

{{ select(17) }}

• 85
• 90
• 95
• 100

18. 执行下面代码后，输出为（ ）。

void adjust(int a, int& b, int* c) {
    a += 3;
    b += 5;
    *c += 7;
}
int main() {
    int x = 2, y = 2, z = 2;
    adjust(x, y, &z);
    cout << x << " " << y << " " << z;
}

{{ select(18) }}

• 5 7 9
• 2 7 9
• 5 2 9
• 2 2 2

19. 执行下面代码后，输出为（ ）。

int value = 4;
void increase(int& val) {
    val += 6;
}
int main() {
    int value = 10;
    increase(value);
    cout << value;
    return 0;
}

{{ select(19) }}

• 4
• 10
• 16
• 6

20. 下列关于结构体初始化的写法，正确的是（ ）。

{{ select(20) }}

• struct Book { string title; int pages; }; Book b = ("C++", 300);
• struct Book { string title; int pages; }; Book b = {"C++", 300};
• struct Book { string title; int pages; }; Book b = new Book("C++", 300);
• struct Book { string title; int pages; }; Book b = <"C++", 300>;

21. 执行下面代码后，输出为（ ）。

struct Student {
    int chinese;
    int math;
};
void changeChinese(Student s) { s.chinese = 95; }
void changeMath(Student& s) { s.math = 95; }
int main() {
    Student s{88, 92};
    changeChinese(s);
    changeMath(s);
    cout << s.chinese << " " << s.math;
}

{{ select(21) }}

• 95 95
• 88 95
• 95 92
• 88 92

22. 关于递推与递归，下列说法正确的是（ ）。

{{ select(22) }}

• 递归算法一定比递推效率更高
• 递推通常用循环实现，从已知条件逐步推导
• 递归不需要终止条件也能正确运行
• 所有递归都能改写为递推且复杂度相同

23. 某排序算法对如下数据按身高（height）升序排序：

初始：(165,'A'), (165,'B'), (160,'C'), (165,'D')；排序后：(160,'C'), (165,'A'), (165,'B'), (165,'D')

关于该排序算法稳定性的说法，正确的是（ ）。

{{ select(23) }}

• 不稳定，因为出现了相同身高
• 稳定，因为相同身高的原始相对顺序保持不变
• 不稳定，因为 C 被移到了最前面
• 无法判断

24. 下面代码试图按升序进行插入排序，横线处应填写（ ）。

void insertionSort(int a[], int n) {
    for(int i = 1; i < n; i++) {
        int key = a[i];
        int j = i - 1;
        while(j >= 0 && ______) {
            a[j+1] = a[j];
            j--;
        }
        a[j+1] = key;
    }
}

{{ select(24) }}

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

25. 下列代码段的时间复杂度为（ ）。

int ans = 0;
for(int i = 0; i < n; i++) {
    for(int j = 0; j < n; j++) {
        if((i * j) % 2 == 0) ans++;
    }
}

{{ select(25) }}

• O(n)
• O(n log n)
• O(n²)
• O(2n)

26. 执行下面代码后，输出为（ ）。

int main() {
    int a[2][3] = {{1,2,3},{4,5,6}};
    cout << a[1][0] + a[0][2];
    return 0;
}

{{ select(26) }}

• 5
• 6
• 7
• 8

27. 执行下面程序，输出结果是（ ）。

int calc(int x, int y) {
    if(y == 0) throw 3;
    return x / y;
}
int main() {
    try {
        cout << calc(9, 0);
    } catch(const char* msg) {
        cout << "ErrX";
    } catch(int) {
        cout << "ErrY";
    }
}

{{ select(27) }}

• ErrX
• ErrY
• 程序崩溃
• 无输出

28. 下列函数实现元素向前（左）移动。当某元素值比前驱大而需要前移时，while 循环条件应为（ ）。

void moveLeft(int arr[], int n, int pos) {
    int cur = arr[pos];
    int i = pos;
    while(______) {
        arr[i] = arr[i - 1];
        i--;
    }
    arr[i] = cur;
}

{{ select(28) }}

• i > 0 && cur > arr[i - 1]
• i > 0 && cur < arr[i - 1]
• i < n - 1 && cur > arr[i + 1]
• i < n - 1 && cur < arr[i + 1]

29. 执行下面代码后，输出为（ ）。

int main() {
    int a = 5;
    int* p = &a;
    *p = *p + 8;
    cout << a;
    return 0;
}

{{ select(29) }}

• 5
• 8
• 13
• 16

30. 执行下面代码后，输出为（ ）。

int main() {
    int x = 8;
    int* p = &x;
    *p = *p - 3;
    cout << x;
    return 0;
}

{{ select(30) }}

• 3
• 5
• 8
• 11

二、多项选择题（每题 3 分）

31. 关于指针的基本概念，下列说法正确的有（ ）。

{{ multiselect(31) }}

• 指针变量存储的是内存地址
• 可以使用 & 运算符获取变量的地址
• 可以使用 * 运算符访问指针指向的内容
• 指针变量不能指向数组元素

32. 关于二维数组，下列说法正确的有（ ）。

{{ multiselect(32) }}

• int (*p)[4] 表示 p 指向包含 4 个 int 的一维数组
• 二维数组名本质是指向第一行的指针
• int* p = arr[0] 可获取二维数组首行首元素地址
• 对于指向二维数组一行的行指针 p，p + 1 会向后跳转一整行的所有元素

33. 关于结构体，下列说法正确的有（ ）。

{{ multiselect(33) }}

• 结构体可以用 {} 进行列表初始化
• 结构体变量值传递时，函数内修改不影响外部
• 结构体变量引用传递时，函数内修改影响外部
• 结构体内部不能定义另一个结构体

34. 关于递推与迭代，下列说法正确的有（ ）。

{{ multiselect(34) }}

• 递推是从已知初始条件逐步推导后续结果
• 迭代通常用循环结构实现
• 所有递归算法理论上都能转化为迭代实现
• 递推算法时间复杂度一定比递归低

35. 关于排序稳定性，下列说法正确的有（ ）。

{{ multiselect(35) }}

• 相等元素排序后相对顺序不变，称为稳定排序
• 冒泡排序在相等时不交换，可保证稳定
• 选择排序可能破坏稳定性
• 插入排序在相等元素处理上是稳定的

36. 关于插入排序，下列说法正确的有（ ）。

{{ multiselect(36) }}

• 每次将当前元素插入已排序部分的合适位置
• 数组接近有序时效率较高
• 最坏时间复杂度为 O(n²)
• while 循环条件 j >= 0 && a[j] > key 用于升序排序

37. 关于时间复杂度，下列说法正确的有（ ）。

{{ multiselect(37) }}

• 单层 for 循环从 0 到 n-1 复杂度为 O(n)
• 嵌套双层循环复杂度为 O(n²)
• 循环内的 if 条件不改变整体复杂度量级
• 所有递归算法复杂度都是 O(2^n)

38. 关于 C++ 文件操作，下列说法正确的有（ ）。

{{ multiselect(38) }}

• freopen("file.txt", "w", stdout) 可将 cout 输出重定向到文件
• streambuf 可临时替换 cout 缓冲区实现重定向
• cout 默认输出到屏幕
• ofstream 对象可用 << 写入文件

39. 关于 C++ 异常处理，下列说法正确的有（ ）。

{{ multiselect(39) }}

• try 块抛出异常后立即跳出并匹配 catch
• catch 按抛出的数据类型进行匹配
• 一个 try 可搭配多个不同的 catch
• 异常未被捕获时程序继续正常运行

40. 关于 C++ 指针操作，下列说法正确的有（ ）。

{{ multiselect(40) }}

• & 运算符获取变量的内存地址
• • 运算符用于指针访问指向的内容
• 指针变量必须用 & 赋值
• 指针变量可以不初始化

三、判断题（每题 1 分）

41. 执行下面代码后，变量 score 的值为 25。

void modify(int& x) {
    x += 12;
}
int main() {
    int score = 13;
    modify(score);
    return 0;
}

{{ select(41) }}

• 正确
• 错误

42. 执行下面代码后，输出结果为 9。

int main() {
    int a[2][5];
    cout << &a[1][4] - &a[0][3] << endl;
    return 0;
}

{{ select(42) }}

• 正确
• 错误

43. 执行下面代码后，输出结果为 25 4。

int value = 4;
void show() {
    int value = 25;
    cout << value << " ";
}
int main() {
    show();
    cout << value;
    return 0;
}

{{ select(43) }}

• 正确
• 错误

44. 执行下面代码后，变量 num 的值变为 30。

void setValue(int* p) {
    *p = 30;
}
int main() {
    int num = 10;
    setValue(&num);
    return 0;
}

{{ select(44) }}

• 正确
• 错误

45. 执行下面代码后，输出结果为 4。

int main() {
    int a[3][3] = {{1,2,3},{4,5,6},{7,8,9}};
    cout << a[2][2] - a[1][1] << endl;
    return 0;
}

{{ select(45) }}

• 正确
• 错误

46. C++ 中，引用一旦绑定变量后，不能再重新绑定。

{{ select(46) }}

• 正确
• 错误

47. C++ 中，值传递方式下，函数内对形参的修改会影响外部实参。

{{ select(47) }}

• 正确
• 错误

48. 函数的引用传递方式中，在函数内部修改形参的值，会改变外部实参变量的值。

{{ select(48) }}

• 正确
• 错误

49. 选择排序和插入排序的时间复杂度均为 O(n²)，因此在任何场景下性能完全相同，可以互相替代。

{{ select(49) }}

• 正确
• 错误

50. 下面程序能将字符串 "GESP Exam" 写入 exam.txt 文件。

ofstream fout("exam.txt");
cout << "GESP Exam";
fout.close();

{{ select(50) }}

• 正确
• 错误