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

第1题. 下⾯的语句中，（ ）正确定义了⼀个计算浮点数x的平方（x²=x*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)
  

• 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题. 给定以下代码.,执⾏代码后，变量 a 的值为（ ）。

void func(int& x) {
	x=x*2;
}
int a = 5;
func(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题. 下⾯的描述中，（ ）不能正确定义⼀个名为 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位，对⼀个 ⾏ 列的⼆维整数数组 array ,假设数组第⼀个元素在内存中的地址为0x7ffee4065820 ，则第2⾏第2个元素的地址 &array[1][1] 为（ ）。

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

{{ select(7) }}

• 0x7ffee4065824

• 0x7ffee4065828

• 0x7ffee406582c

• 0x7ffee4065830

  第8题. 下⾯（ ）正确定义⼆维数组。

{{ select(8) }}

• int a[3][];
  

• int a[][];
  

• int a[][4];
  

• int a[][4]={{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²)
• 冒泡排序在任何情况下的时间复杂度都为O(n²)
• 如果给定数据部分有序，插⼊排序通常⽐选择排序效率更⾼

第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题. 给定如下代码，其时间复杂度为（ ）。

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

{{ select(12) }}

• O(n²)
• O(2ⁿ⁾
• O(1)
• O(n)

第13题. 下⾯代码实现了插⼊排序函数，则横线上应填写Q（ ）。

void insertion_sort(vector<int>&nusm) {
	fot(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 - 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) }}

• 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 << "This output will go to the log file." << endl;
  cout.rdbuf(oorg_cout);
  

第15题. 运⾏下⾯的代码，将出现什么情况？（ ）

#include<bits/stdc++.h>
using namespace std;
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分）

第16题. 在 C++ 中，下⾯代码可以正确定义指针和初始化指针。（ ）

int* ptr;
*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²)。（ ）

{{ select(21) }}

• √
• ×

第22题. 冒泡排序的平均时间复杂度为O(n²)，但最优情况下为O(n)。（ ）

{{ select(22) }}

• √
• ×

第23题. 冒泡排序和插⼊排序都是稳定的排序算法。（ ）

{{ select(23) }}

• √
• ×

第24题. 选择排序是稳定的排序算法。（ ）

{{ select(24) }}

• √
• ×

第25题. 在 C++语⾔中，如果⼀个函数可能抛出异常，那么⼀定要在try ⼦句⾥调⽤这个函数。（ ）

{{ select(25) }}

• √
• ×