1 单选题（每题 $2$ 分，共 $30$ 分）

1. 下列关于函数形参与实参的说法，正确的是（ ）{{ select(1) }}

• 实参的数量可以少于形参的数量
• 形参在函数定义时就必须确定具体的值
• 形参和实参必须使用相同的变量名
• 函数调用时，实参的值会传递给形参

2. 执行以下代码，输出结果是（ ）

#include <iostream>
using namespace std;

struct Point
{
    int x, y;
};

int main()
{
    Point p = {2, 5};
    Point q = p;
    q.x = 10;
    cout << p.x + q.x + p.y + q.y;
    return 0;
}

{{ select(2) }}

• 14
• 22
• 24
• 32

3. 执行以下代码，输出结果是（ ）

#include <iostream>
using namespace std;

int main()
{
    int a = 10, b = 20;
    int* p = &a;
    p = &b;
    *p = 30;
    cout << a << " " << b;
    return 0;
}

{{ select(3) }}

• 10 20
• 30 20
• 10 30
• 30 30

4. 使用冒泡排序将数组 {5, 1, 4, 2, 8} 按升序排列，第一趟排序结束后，数组变为（ ）{{ select(4) }}

• {1, 4, 2, 5, 8}
• {1, 2, 4, 5, 8}
• {1, 5, 4, 2, 8}
• {5, 1, 4, 2, 8}

5. 执行以下代码，输出结果是（ ）（默认已包含 <iostream>、<string> 等必要头文件，已使用 using namespace std;，代码位于 main 函数中）

struct Student
{
    string name;
    int score;
};

Student stu[3] = {{"A", 90}, {"B", 85}, {"C", 95}};
cout << stu[2].score - stu[0].score;

{{ select(5) }}

• 10
• 5
• 15
• 编译错误

6. 执行以下代码，输出结果是（ ）

#include <iostream>
using namespace std;

int main()
{
    int a[4] = {1, 3, 5, 7};
    int* p = a;
    cout << *(p + 3) - *p;
    return 0;
}

{{ select(6) }}

• 4
• 8
• 2
• 6

7. 关于排序算法的稳定性，下列说法正确的是（ ）{{ select(7) }}

• 稳定性指排序后关键字相等的元素之间的相对顺序保持不变
• 稳定性指排序算法的时间复杂度始终保持不变
• 所有排序算法都是稳定的
• 稳定性指排序结果一定是升序

8. 执行以下代码，输出结果是（ ）

#include <iostream>
using namespace std;

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

{{ select(8) }}

• 5
• 7
• 9
• 编译错误

9. 已知数列 $a$ 满足 $a[0] = 1$，$a[1] = 1$，$a[i] = a[i-1] + a[i-2]$（$i \ge 2$），则 $a[5]$ 的值是（ ）{{ select(9) }}

• 5
• 6
• 8
• 13

10. 下列关于 C++ 文件流的说法，正确的是（ ）{{ select(10) }}

• ofstream 类用于从文件中读取数据
• ifstream 类用于向文件中写入数据
• 打开文件失败时，对应的流对象为假
• 使用完文件后不需要关闭文件

11. 执行以下代码，输出结果是（ ）

#include <iostream>
using namespace std;

void f(int &x)
{
    x = x * 2;
}

int main()
{
    int a = 6;
    f(a);
    cout << a;
    return 0;
}

{{ select(11) }}

• 12
• 6
• 编译错误
• 0

12. 下列关于 C++ 异常处理的说法，正确的是（ ）{{ select(12) }}

• 一个 try 块后只能有一个 catch
• catch(...) 不能捕获任何异常
• 抛出异常后程序一定立即结束
• throw 抛出的异常可以被 catch 捕获

13. 某算法的执行时间与输入规模 $n$ 的关系约为 $2^n$ 微秒。当 $n$ 增大 $1$ 时，该算法的执行时间大约会（ ）{{ select(13) }}

• 变为原来的 $4$ 倍
• 变为原来的 $2$ 倍
• 增加 $2$ 微秒
• 变为原来的 $2^n$ 倍

14. 执行以下代码，输出结果是（ ）

#include <iostream>
using namespace std;

void f(int x)
{
    x = x + 10;
}

int main()
{
    int a = 5;
    f(a);
    cout << a;
    return 0;
}

{{ select(14) }}

• 15
• 10
• 编译错误
• 5

15. 下列关于指针与数组的说法，正确的是（ ）{{ select(15) }}

• 数组名可以看作指向首元素的指针
• 数组名可以被重新赋值
• int a[5]; int* p = a; 中 p 指向 a 的最后一个元素
• 数组和指针之间没有任何联系

2 判断题（每题 $2$ 分，共 $20$ 分）

1. 形参为引用类型时，函数内对形参的修改会影响实参。{{ select(16) }}

• 正确
• 错误

2. 冒泡排序每一趟都会把当前未排序部分中的最大（或最小）元素移动到正确的位置。{{ select(17) }}

• 正确
• 错误

3. 两个同类型的结构体变量之间可以直接用 = 整体赋值。{{ select(18) }}

• 正确
• 错误

4. freopen("in.txt", "r", stdin); 可以把标准输入重定向到文件 in.txt。{{ select(19) }}

• 正确
• 错误

5. int arr[3][4]; 一共包含 $12$ 个 int 类型的元素。{{ select(20) }}

• 正确
• 错误

6. 递推算法在运行过程中会自己调用自己。{{ select(21) }}

• 正确
• 错误

7. 排序算法的稳定性是指排序过程中任意两个元素都不会交换位置。{{ select(22) }}

• 正确
• 错误

8. 使用完文件后不调用 close()，其他程序将永远无法打开该文件。{{ select(23) }}

• 正确
• 错误

9. try 块中的代码抛出异常后，会跳转到相应的 catch 块继续执行。{{ select(24) }}

• 正确
• 错误

10. 局部变量在整个程序运行期间都会占用内存。{{ select(25) }}

• 正确
• 错误