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

$1、$​​ 下面的语句中，（ ）正确定义了一个计算浮点数 $x$ 的平方($x^2=x*x$ )的函数,并成功调用该函数

{{ select(1) }}

• 
• 
• 
• 

$2、$ 下面代码的描述中，正确的是（ ）。

01 void n_chars(char c, int n) {
02 	while (n-- > 0)
03 		cout << c;
04 }
05 char my_char = 'w';
06 int times = 5;
07 n_chars(my_char, times);

{{ select(2) }}

• 代码执行结束后， $times$ 的值为 0
• $n$ 是形参， $times$ 是实参
• $n$ 是实参， $times$ 是形参
• 代码最后一行换成 n_chars(times, my_char); 也可以

$3、$ 给定以下代码，

01 void func(int& x) {
02   x = x * 2;
03 }
04 int a = 5;
05 func(a);

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

{{ select(3) }}

• 5
• 10
• 15
• 20

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

01 double* p_arr = new double [3];
02 p_arr[0] = 0.2;
03 p_arr[1] = 0.5;
04 p_arr[2] = 0.8;
05 p_arr += 1;
06 cout << p_arr[0] << endl;
07 p_arr -= 1;
08 delete p_arr;

{{ select(4) }}

• 0.2
• 0.5
• 1.2
• 1.5

$5、$ 运行下面代码片段后， $x$ 和 $*p$ 的结果分别是（ ）。

01 int x = 20;
02 int* p = &x;
03 *p = *p + 2；

{{ select(5) }}

• 20 20
• 20 22
• 22 20
• 22 22

$6、$ 下面的描述中，（ ）不能正确定义一个名为 Student 的结构体以及一个包含 $20$ 个元素的结构数组。

{{ select(6) }}

• 
• 
• 
• 

$7、$ 假定整型是 $32$ 位，对一个 $2$ 行 $3$ 列的二维整数数组 array ,假设数组第一个元素在内存中的地址为 0x7ffee4065820 ，则第 $2$ 行第 $2$ 个元素的地址 &array[1][1] 为（ ）。

01 int array[2][3] = {
02 {0, 1, 2},
03 {3, 4, 5}
04 };

{{ select(7) }}

• 0x7ffee4065824
• 0x7ffee4065828
• 0x7ffee406582c
• 0x7ffee4065830

$8、$ 下面（ ）正确定义二维数组。

{{ select(8) }}

• int a[3][];
• int a[][];
• int a[][4];
• int a[][2] = {{1,2},{1,2},{3,4}};

$9、$ 下面代码采用递推算法来计算斐波那契数列$f(n)=f(n-1)+f(n-2)$ ，则横线上应填写（ ）。

01 int fib(int n) {
02   if (n == 0 || n == 1)
03     return n;
04   int f1 = 0;
05   int f2 = 1;
06   int result = 0;
07   for (int i = 2; i <= n; i++) {
08     ________________________________ // 在此处填入代码
09   }
10   return result;
11 }

{{ select(9) }}

• 
• 
• 
• 

$10、$ 下面关于排序算法（冒泡排序、插入排序和选择排序）的描述中，不正确的是（ ）。

{{ select(10) }}

• 冒泡排序基于元素交换实现，需借助临时变量，共涉及 $3$ 个单元操作；而插入排序基于元素赋值实现，仅需 $1$ 个单元操作。因此冒泡排序的计算开销通常比插入排序更高。
• 选择排序在任何情况下的时间复杂度都为 $O(n^2)$。
• 冒泡排序在任何情况下的时间复杂度都为 $O(n^2)$。
• 如果给定数据部分有序，插入排序通常比选择排序效率更高。

$11、$ 冒泡排序的第一轮操作是从左到右遍历数组，通过两两比较相邻元素，将当前最大的元素移动到末尾。给定数组 arr[]={4, 1, 3, 1, 5, 2} ，执行第一轮冒泡排序后数组 arr 中的内容为（ ）。

{{ select(11) }}

• 1, 4, 3, 1, 5, 2
• 1, 3, 1, 4, 2, 5
• 1, 4, 3, 1, 2, 5
• 4, 1, 3, 1, 5, 2

$12、$ 给定如下代码，其时间复杂度为（ ）。

01 int cellRecur(int n) {
02   if (n == 1)
03     return 1;
04   return cellRecur(n - 1) + cellRecur(n - 1) + 1;
05 }

{{ select(12) }}

• $O(n^2)$
• $O(2^n)$
• $O(1)$
• $O(n)$

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

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

{{ select(13) }}

• int base = nums[i], j = i - 1;
• int base = nums[i], j = i;
• int base = nums[0], j = i - 1;
• int base = nums[0], j = i;

$14、$ 下面哪种方式不能实现将字符串 "Welcome to GESP!" 输出重定向到文件 log.txt （ ）。

{{ select(14) }}

• 
• 
• 
• 

$15、$ 运行下面的代码，将出现什么情况？（ ）

01 double hmean(double a, double b) {
02   if (a == -b )
03     throw runtime_error("Runtime error occurred");
04   return 2.0*a*b/(a + b);
05 }
06 int main() {
07   double x = 10;
08   double y = -10;
09   try {
10     int result = hmean(x, y);
11     cout << "hmean: " << result << endl;
12   }
13   catch (const runtime_error& e) {
14     cout << "Caught: " << e.what() << endl;
15   } catch (...) {
16     cout << "Caught an unknown exception." << endl;
17   }
18   return 0;
19 }

{{ select(15) }}

• 屏幕上输出 Caught: Runtime error occurred
• 屏幕上输出 Caught an unknown exception
• 程序调用 std::terminate()
• 编译错误

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

$16、$ 在 $C++$ 中，下面代码可以正确定义指针和初始化指针。

01 int* ptr;
02 *ptr = 10;

{{ select(16) }}

• 正确
• 错误

$17、$ 一个函数必须在调用之前既声明又定义。

{{ select(17) }}

• 正确
• 错误

$18、$ 函数参数可以通过值传递、引用传递和指针传递，这样函数内对参数的修改可以直接修改传入变量的值。

{{ select(18) }}

• 正确
• 错误

$19、$ int arr[3][] 是一个正确的二维数组的声明。

{{ select(19) }}

• 正确
• 错误

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

{{ select(20) }}

• 正确
• 错误

$21、$ 某算法的递推关系式为 $T(n)=T(n-1)+n （n 为正整数）$及$T(0)=1$ ，则该算法的时间复杂度为 $O(n^2)$。

{{ select(21) }}

• 正确
• 错误

$22、$ 冒泡排序的平均时间复杂度为 $O(n^2)$，但最优情况下为 $O(n)$。

{{ select(22) }}

• 正确
• 错误

$23、$ 冒泡排序和插入排序都是稳定的排序算法。

{{ select(23) }}

• 正确
• 错误

$24、$ 选择排序是稳定的排序算法。

{{ select(24) }}

• 正确
• 错误

$25、$ 在 $C++$ 语言中，如果一个函数可能抛出异常，那么一定要在 $try$ 子句里调用这个函数

{{ select(25) }}

• 正确
• 错误