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

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

{{ select(1) }}

• float square(float x) {
      return x * x;
  }
  float area = square(2);
  

• square(float x) {
      return x * x;
  }
  float area = square(2);
  

• void square(float x) {
      return x * x;
  }
  area = square(2.0);
  

• void square(float x) {
      x * x;
      return ;
  }
  area = square(2);
  

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

   void n_chars(char c, int n) {
       while (n-- > 0)
           cout << c;
   }
   
   char my_char = 'w';
   int times = 5;
   n_chars(my_char, times);
   

{{ select(2) }}

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

3. 给定以下代码

   void func(int& x) {
       x = x * 2;
   }
   
   int a = 5;
   func(a);
   

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

{{ select(3) }}

• $5$
• $10$
• $15$
• $20$

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

   double* p_arr = new double [3];
   p_arr[0] = 0.2;
   p_arr[1] = 0.5;
   p_arr[2] = 0.8;
   p_arr += 1;
   cout << p_arr[0] << endl;
   p_arr -= 1;
   delete p_arr;
   

{{ select(4) }}

• $0.2$
• $0.5$
• $1.2$
• $1.5$

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

   int x = 20;
   int* p = &x;
   *p = *p + 2；
   

{{ select(5) }}

• $20\ 20$
• $20\ 22$
• $22\ 20$
• $22\ 22$

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

{{ select(6) }}

• struct Student {
      string name;
      int age;
      float score;
  };
  struct Student students[20];
  

• struct Student {
      string name;
      int age;
      float score;
  };
  Student students[20];
  

• struct Student {
      string name;
      int age;
      float score;
  };
  Student* students = new Student[20];
  

• struct Student {
      string name;
      int age;
      float score;
  };
  Student students = new Student[20];
  

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

   int array[2][3] = {
       {0, 1, 2},
       {3, 4, 5}
   };
   

{{ select(7) }}

• $\tt 0x7ffee4065824$
• $\tt 0x7ffee4065828$
• $\tt 0x7ffee406582c$
• $\tt 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)$，则横线上应填写（ ）。

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

{{ select(9) }}

• result = f1 + f2;
  f1 = f2;
  f2 = result;
  

• result += f1 + f2;
  f1 = f2;
  f2 = result;
  

• result += f1 + f2;
  f2 = result;
  f1 = f2;
  

• result = f1 + f2;
  f2 = result;
  f1 = f2;
  

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

{{ select(10) }}

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

11. 冒泡排序的第一轮操作是从左到右遍历数组，通过两两比较相邻元素，将当前最大的元素移动到末尾。给定数组 arr[] = {4, 1, 3, 1, 5, 2}，执行第一轮冒泡排序后数组 $\tt 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. 给定如下代码，其时间复杂度为（ ）。

    int cellRecur(int n) {
        if (n == 1)
            return 1;
        return cellRecur(n - 1) + cellRecur(n - 1) + 1;
    }
    

{{ select(12) }}

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

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

    void insertion_sort(vector<int> &nums) {
        for (int i = 1; i < nums.size(); i++) {
            ________________________________ // 在此处填入代码
            while (j >= 0 && nums[j] > base) { 
                nums[j + 1] = nums[j];
                j--;
            }
            nums[j + 1] = base;
        }
    }
    

{{ 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!" 输出重定向到文件 $\tt log.txt$？（ ）

{{ select(14) }}

• freopen("log.txt", "w", stdout);
  cout << "Welcome to GESP!" << endl;
  fclose(stdout);
  

• std::ofstream outFile("log.txt");
  outFile << "Welcome to GESP!" << endl;
  outFile.close();
  

• std::ofstream outFile("log.txt");
  cout << "Welcome to GESP!" << endl;
  outFile.close();
  

• ofstream log_file("log.txt");
  streambuf* org_cout = cout.rdbuf();
  cout.rdbuf(log_file.rdbuf());
  cout << "Welcome to GESP!" << endl;
  cout.rdbuf(org_cout);
  

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

    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;
    }
    

{{ select(15) }}

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

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

1. 在 $\tt C$++ 中，下面代码可以正确定义指针和初始化指针。（ ）

   int* ptr;
   *ptr = 10;
   

{{ select(16) }}

• 正确
• 错误

2. 一个函数必须在调用之前既声明又定义。（ ）

{{ select(17) }}

• 正确
• 错误

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

{{ select(18) }}

• 正确
• 错误

4. int arr[3][] 是一个正确的二维数组的声明。（ ）

{{ select(19) }}

• 正确
• 错误

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

{{ select(20) }}

• 正确
• 错误

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

{{ select(21) }}

• 正确
• 错误

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

{{ select(22) }}

• 正确
• 错误

8. 冒泡排序和插入排序都是稳定的排序算法。（ ）

{{ select(23) }}

• 正确
• 错误

9. 选择排序是稳定的排序算法。（ ）

{{ select(24) }}

• 正确
• 错误

10. 在 $\tt C$++ 语言中，如果一个函数可能抛出异常，那么一定要在 $\tt try$ 子句里调用这个函数。（ ）

{{ select(25) }}

• 正确
• 错误