单选题（共 15 题）

1. 在 C++ 中，（ ）正确定义了一个返回整数值并接受两个整数参数的函数。{{ select(1) }}

•   int add(int a, int b) { return a + b; }
  

• void add(int a, int b) { return a + b; }
  

• int add(a, b) { return a + b; }
  

• void add(int a, int b) { return a - b; }
  

2. 在 C++ 中，形参与实参的关系描述正确的是（ ）。{{ select(2) }}

• 形参在函数调用时指定，实参在函数定义时传递
• 形参在函数定义时指定，实参在函数调用时传递
• 形参和实参可以互换
• 形参和实参必须是完全相同的类型，不能有任何差异。

#include <iostream
using namespace std;

int var = 100;

void function() {
    int var = 200;
    cout << var <<  " ";
    cout << ::var <<  " ";
}

int main() {
    cout << var << " ";
    function();
    var += 100;
    cout << var << " ";
}

运⾏以上代码，屏幕上将输出（ ）。{{ select(3) }}

• 100 200 100 200
• 100 200 100 300
• 100 200 200 200
• 100 200 200 300

int arr[3] = {24, 9, 7};
int* p = arr;
p++;
cout << *p << endl;

运⾏下⾯代码，屏幕上输出是（ ）。{{ select(4) }}

• 24
• 9
• 7
• 不确定

int x = 20;
int y = 24;
int* p = &x;
int* q = &y;
p = q;

运⾏下⾯代码片段的结果是（ ）。{{ select(5) }}

• 将 x 赋值为24
• 将 x 赋值为20
• 将 p 指向的地址
• 将 p 指向的地址

6. 在 C++ 中，（ ）正确定义一个名为 student 的结构体，其中包含一个 name 字符数组和一个 age 整数。{{ select(6) }}

• struct student { char name[20]; int age; };
  

• student struct { char name[20]; int age; };
  

• student struct { string name; int age; };
  

• struct student { char[20] name; int age; };
  

7. 在 C++ 中，（ ）正确声明了一个 3 行 4 列的二维数组。{{ select(7) }}

• int arr[3, 4];
• int arr[3][4];
• int arr[4][3];
• int arr(3, 4);

8. 一个二维数组定义为 int arr[3][4]; （假设一个int变量占4个字节），则 int arr[0] 占用（ ）个字节的内存。 {{ select(8) }}

• 3
• 4
• 12
• 16

int factorial(int n) {
    int result = 1;
    for (int i = 2; i <= n; i++) {
        ________________________________     // 在此处填入代码
    }
    return result;
}

上⾯代码采用递推算法来实现整数阶乘（ ），则横线上应填写（ ）。{{ select(9) }}

• result *= i;
• result += i;
• result *= result;
• result += result;

10. 在排序算法中，稳定性指的是（ ）。{{ select(10) }}

• 排序后数据不会丢失
• 排序后相同元素的相对顺序保持不变
• 排序后数据不会被修改
• 排序后数据的时间复杂度不变

int bubble_sort(vector<int&arr) {
    for (int i = arr.size() - 1; i 0; i--) {
        bool flag = false; // 标志位
        ________________________________ {    // 在此处填入代码
            if (arr[j] arr[j + 1]) {
                swap(arr, i, j);
                flag = true;
            }
        }
        if (!flag)
            break; // 此轮“冒泡”未交换任何元素
    }
}

上⾯代码实现了冒泡排序函数，则横线上应填写（ ）。{{ select(11) }}

• for (int j = 0; j < arr.size() - 1; j++)
• for (int j = arr.size() - 1; j 0; j--)
• for (int j = 0; j < i; j++)
• for (int j = i-1; j <= 0; j--)

12. 上题算法的时间复杂度为（ ）。{{ select(12) }}

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

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

上⾯代码实现了插入排序函数（升序），则横线上应填写（ ）。{{ select(13) }}

• while (j = 0 && nums[j] base)
• while (j 0 && nums[j] base)
• while (j = 0 && nums[j] < base)
• while (j 0 && nums[j] < base)

ofstream log_file("log.txt");
log_file << "This output will go to the log file." << endl;

小杨用文件重定向实现在 log.txt 文件中输出日志，则下⾯横线上应填写（ ）。{{ select(14) }}

• cout << "This output will go to the log file." << endl;
• log_file << "This output will go to the log file." << endl;
• cout "This output will go to the log file." endl;
• log_file "This output will go to the log file." endl;

#include <iostream>
using namespace std;
int divide(int a, int b) {
  if (b == 0) {
  throw runtime_error("division by zero error ");
  }
  return a / b;
}
int main() {
  int x = 10;
  int y = 0; // 设为 0 会导致除零错误
  try {
    int result = divide(x, y);
    cout << "result: " << result << endl;
  } catch (const runtime_error& e) {
    cout << "caught an exception: " << e.what() << endl;
  }
  return 0;
}

运⾏下⾯的代码，屏幕上将输出（ ）。{{ select(15) }}

• division by zero error result: caught an exception:
• result: caught an exception: division by zero error
• caught an exception: division by zero error
• division by zero error caught an exception: division by zero error

int main() {
    int x = 10;
    int y = 0;  // 设为 0 会导致除零错误
    try {
        int result = divide(x, y);
        cout << "result: " << result << endl;
    } catch (const runtime_error& e) {
        cout << "caught an exception: " << e.what() << endl;
    }
    return 0;
}

判断题（共 10 题）

16. 代码 int a = 10; int* p = &a; 可以正确定义指针和初始化指针。{{ select(16) }}

• 对
• 错

17. 在 C++ 中，引用传递允许函数修改传递给它的参数的值。{{ select(17) }}

• 对
• 错

18. 指针的大小与其所指向的变量的数据类型的大小相同。{{ select(18) }}

• 对
• 错

19. 二维数组的行的大小必须在定义时确定，列的大小可以动态变化。{{ select(19) }}

• 对
• 错

20. 递推算法通过逐步求解当前状态和前一个或几个状态之间的关系来解决问题。{{ select(20) }}

• 对
• 错

21. 选择排序是稳定的排序算法。{{ select(21) }}

• 对
• 错

22. 插入排序的时间复杂度总是比冒泡排序低。{{ select(22) }}

• 对
• 错

23. 在 C++ 中，如果没有捕获到异常（没有匹配的 catch 块），程序会继续执行而不会终止。{{ select(23) }}

• 对
• 错

24. 以下代码用递推法求斐波那契数列的第 n 项，时间复杂度为指数级。{{ select(24) }}

• 对
• 错

int main() {
    int a = 10;
    int* p = &a;
    *p = point(p);
    cout << *p << endl;
}

执行上述 C++ 代码后，输出的是 20。{{ select(25) }}

• 对
• 错