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

第 1 题 执行下面程序后，输出为 ( )

01 int f(int x = 2){
02     return x * 3;
03 }
04 
05 int main(){
06     cout << f() << " " << f(4);
07 }

{{ select(1) }}

• 2 12
• 6 12
• 6 4
• 12 6

第 2 题 执行下面代码后，输出为 ( )

01 int main() {
02     int a = 5;
03     int* p = &a;
04     int** q = &p;
05     **q += 7;
06     cout << a << " " << *p;
07 }

{{ select(2) }}

• 5 5
• 12 12
• 12 5
• 5 12

第 3 题 已知:

01 int a[3][4] = {
02     {1,2,3,4},
03     {5,6,7,8},
04     {9,10,11,12}
05 };
06 int (*p)[4] = a;

则表达式 *(*(p+2)+1) 的值为 ( )

{{ select(3) }}

• $6$
• $10$
• $9$
• $11$

第 4 题 执行下面程序后，输出为( )。

01 void fun(int a, int &b, int *c){
02     a += 1;
03     b += 2;
04     *c += 3;
05 }
06 
07 int main(){
08     int x = 1, y = 1, z = 1;
09     fun(x, y, &z);
10     cout << x << " " << y << " " << z;
11 }

{{ select(4) }}

• 2 3 4
• 1 3 4
• 2 1 4
• 1 1 1

第 5 题 执行下面程序后输出为 ( )

01 int x = 3;
02 void f(int& x){
03     x += 2;
04 }
05 int main(){
06     int x = 10;
07     f(x);
08     cout << x << " " << ::x;
09 }

{{ select(5) }}

• 12 3
• 10 5
• 12 5
• 10 3

第 6 题 下列关于结构体初始化的写法，正确的是 ( )

{{ select(6) }}

• 01 struct Point { int x, y; };
  02 
  03 Point p = (1,2);
  

• 01 struct Point { int x, y; };
  02 
  03 Point p = {1,2};
  

• 01 struct Point { int x, y; };
  02 
  03 Point p = new Point(1,2);
  

• 01 struct Point { int x, y; };
  02 
  03 Point p = <1,2>;
  

第 7 题 执行下面代码后输出为 ( )

01 struct S { int a; int b; };
02 
03 void g(S s){ s.a += 10; }
04 void h(S& s){ s.b += 10; }
05 
06 int main(){
07     S s{1,2};
08     g(s);
09     h(s);
10     cout << s.a << " " << s.b;
11 }

{{ select(7) }}

• 11 12
• 1 12
• 11 2
• 1 2

第 8 题 关于递推算法的描述，正确的是 ( )

{{ select(8) }}

• 递推表现为函数自己调用自己
• 递推从已知初值出发，利用递推关系逐步推出后续结果
• 递推只能用于指数复杂度问题
• 递推一定需要回溯

第 9 题 执行 climb(6) 的返回值为 ( )

01 int climb(int n){
02     if(n <= 2) return n;
03     int a = 1, b = 2, c = 0;
04     for(int i = 3; i <= n; i++){
05         c = a + b;
06         a = b;
07         b = c;
08     }
09     return c;
10 }

{{ select(9) }}

• $8$
• $13$
• $5$
• $10$

第 10 题 某排序算法对如下数据排序(按 $score$ 升序)，则下面关于该排序算法稳定性的描述中，说法正确的是( )

初始: (90,'A'), (90,'B'), (80,'C'), (90,'D')

排序后: (80,'C'), (90,'A'), (90,'B'), (90,'D')

{{ select(10) }}

• 不稳定，因为出现了相同分数
• 稳定，因为相同 $score$ 的相对顺序保持为 $A$ 在 $B$ 前、$B$ 在 $D$ 前
• 不稳定，因为 $C$ 跑到前面了
• 无法判断

第 11 题 下面代码试图把数组按升序进行“插入排序”，横线处应填写 ( )

01 void ins(int a[], int n){
02     for(int i = 1; i < n; i++){
03         int key = a[i];
04         int j = i-1;
05         while(j >= 0 && __________){
06             a[j+1] = a[j];
07             j--;
08         }
09         a[j+1] = key;
10     }
11 }

{{ select(11) }}

• a[j] < key
• a[j] > key
• a[j+1]> key
• a[j] == key

第 12 题 下列代码段的时间复杂度为 ( )

01 int cnt=0;
02 for(int i=0; i<n; i++){
03     for(int j=0; j<n; j++){
04         if( (i+j) % 3 == 0) cnt++;
05     }
06 }

{{ select(12) }}

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

第 13 题 下面哪种方式不能实现将字符串 Welcome to 2026! 输出重定向到文件Log.txt ( )

{{ select(13) }}

• 01 freopen("log.txt", "w", stdout);
  02 cout << "Welcome to 2026!" << endl; 
  03 fclose(stdout);
  

• 01 std::ofstream outFile("log.txt");
  02 cout << "Welcome to 2026!" << endl; 
  03 outFile.close();
  

• 01 ofstream log_file("log.txt");
  02 streambuf* org_cout = cout.rdbuf();  
  03 cout.rdbuf(log_file.rdbuf());             
  04 cout << "Welcome to 2026!" << endl;
  05 cout.rdbuf(org_cout);  
  

• 01 std::ofstream outFile("log.txt");
  02 outFile << "Welcome to 2026!" << endl; 
  03 outFile.close();
  

第 14 题 执行下面程序，输出结果是 ( )

01 int divi(int a,int b){
02     if(b==0) throw 0;
03     return a/b;
04 }
05 
06 int main(){
07     try{
08         cout << divi(10,0);
09     }catch(const char* msg){
10         cout << "A";
11     }catch(int){
12         cout << "B";
13     }
14 }

{{ select(14) }}

• A
• B
• 程序崩溃
• 无输出

第 15 题 下列函数实现排行榜中单个元素的位置调整(类似插入排序的相邻搬移)。当某玩家分数增加，需将其向前移动时，while 循环的条件应为 ( )

01 struct Player{ int score; };
02 void up(Player players[], int n, int idx){
03     Player cur = players[idx];
04     int i = idx;
05     while( ____________________ ){
06         players[i] = players[i-1];
07         i--;
08     }
09     players[i] = cur;
10 }

{{ select(15) }}

• i > 0 && cur.score > players[i-1].scoreB
• i > 0 && cur.score < players[i-1].score
• i < n-1 && cur.score > players[i+1].score
• i < n-1 && cur.score < players[i+1].score

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

第 1 题 下面代码执行结束时，变量 a 的值变成 $15$。

01 void add10(int &x) { x += 10; }
02 
03 int main() {
04     int a = 5;
05     add10(a);
06 }

{{ select(16) }}

• 正确
• 错误

第 2 题 引用一旦绑定某个变量，就不能再绑定其他变量。

{{ select(17) }}

• 正确
• 错误

第 3 题 执行下面代码，输出结果为 5。

01 int main() {
02     int a[2][3];
03     cout << &a[1][2] - &a[0][1] << endl;
04     return 0;
05 }

{{ select(18) }}

• 正确
• 错误

第 4 题 下面程序可以正常编译并输出10。

01 int calc(int x, int y = 10);
02 int calc(int x) { return x * 2; }
03 int calc(int x, int y) { return x * y; }
04 
05 int main() {
06     cout << calc(5);
07 }

{{ select(19) }}

• 正确
• 错误

第 5 题 下面程序执行后输出 2010。

01 int x = 10;
02 void f() { int x = 20; cout << x; }
03 
04 int main() {
05     f();
06     cout << x;
07 }

{{ select(20) }}

• 正确
• 错误

第 6 题 在 C++ 中，如果声明了一个指针变量但没有显式初始化，该指针会自动被初始化为 nullptr。

{{ select(21) }}

• 正确
• 错误

第 7 题 下面代码没有语法错误。

01 struct GameCharacter {
02     string name;
03     int level;
04     float position_x;
05     float position_y;   
06 
07     struct Equipment {
08         string weapon;
09         int attack_bonus;
10         int defense_bonus;
11     } equipment;
12
13     struct Skill {
14         string name;
15         int damage;
16     } skills[8];
17     int skill_count;
18 };

{{ select(22) }}

• 正确
• 错误

第 8 题 下面程序能够把 Hello 写入 data.txt 文件中。

01 ofstream fout("data.txt");
02 cout << "Hello";
03 fout.close();

{{ select(23) }}

• 正确
• 错误

第 9 题 由于选择排序和插入排序的时间复杂度均为 $O(n^2)$，在任何实际场景下两者的性能表现几乎相同，可以互相替代。

{{ select(24) }}

• 正确
• 错误

第 10 题 下面用递推方式计算斐波那契数列第 $n$ 项的程序，时间复杂度是$O(2^n)$。

01 int fib(int n) {
02     if (n <= 1) return n;
03     int f0 = 0, f1 = 1, cur = 0;
04     for (int i = 2; i <= n; i++) {
05         cur = f0 + f1;
06         f0 = f1;
07         f1 = cur;
08     }
09     return cur;
10 }

{{ select(25) }}

• 正确
• 错误