首页 › 试卷 › GESP编程能力等级认证 › GESP-C++四级 › 2024年9月CCF-GESP编程能力等级认证C++编程四级真题

2024年9月CCF-GESP编程能力等级认证C++编程四级真题 VIP

GESP-C++四级 共 27 题 2024 年 含标准答案与解析
返回试卷列表
本页为整卷浏览:先自己做一遍,再展开「查看答案与解析」核对。

一、单选题

1. 单选题

在 C++ 中,( )正确定义了一个返回整数值并接受两个整数参数的函数。

  • A int add(int a, int b) { return a + b; }
  • B void add(int a, int b) { return a + b; }
  • C int add(a, b) { return a + b; }
  • D void add(int a, int b) { return a - b; }
查看答案与解析
答案:A
解析:

A定义了一个返回类型为int 的函数add,它接受两个int 类型的参数,并正确地返回它们的和。

B定义了一个返回类型为void 的函数,不能返回任何值,所以不符合题意。

C缺少参数类型声明,a和b 必须指定为int 类型。

D同样定义了一个返回类型为void 的函数,不能返回值

2. 单选题

在C++中,形参与实参的关系描述正确的是( )。

  • A 形参在函数调用时指定,实参在函数定义时传递
  • B 形参在函数定义时指定,实参在函数调用时传递
  • C 形参和实参可以互换
  • D 形参和实参必须是完全相同的类型,不能有任何差异。
查看答案与解析
答案:B
解析:

A错误,形参是在函数定义时指定,实参是在函数调用时传递的。

B正确,形参确实是在函数定义中声明的,而实参是在函数调用时提供的。

C错误,形参和实参不能互换,形参是函数定义中的占位符,实参是实际传递的值。

D错误,形参和实参不必完全相同类型,但必须兼容,例如可以使用类型转换。

3. 单选题

运行以下代码,屏幕上将输出( )。

#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 << " ";
	
	return 0;
}
  • A 100 200 100 200
  • B 100 200 100 300
  • C 100 200 200 200
  • D 100 200 200 300
查看答案与解析
答案:A
解析:

main函数:首先输出全局变量var,其值为100。

调用function:局部变量var 被定义为200,所以cout << var << " "; 输出200。

cout << ::var << " "; 仍然输出全局变量var,其值未改变,输出100。

回到main 函数:此时全局var 仍然是100,输出200,所以最后输出的结果是100 200 100 200。

4. 单选题

运行下面代码,屏幕上输出是( )。

int arr[3] = {24, 9, 7};
int* p = arr;
p++;
cout << *p << endl;
  • A 24
  • B 9
  • C 7
  • D 不确定
查看答案与解析
答案:B
解析:

int arr[3] = {24, 9, 7}; 定义了一个包含三个整数的数组。

int* p = arr; 将指针p 指向数组的第一个元素arr[0],即24。

p++;将指针p 移动到数组的下一个元素,即arr[1],此时p 指向9。

cout << *p << endl; 输出p 当前指向的值,即9

5. 单选题

运行下面代码片段的结果是( )。

int x = 20;
int y = 24;
int* p = &x;
int* q = &y;
p = q;
  • A 将 x xx 赋值为24
  • B 将 y yy 赋值为20
  • C 将 q qq 指向 x xx 的地址
  • D 将 p pp 指向 y yy 的地址
查看答案与解析
答案:D
解析:

int x = 20; 和int y = 24; 定义了两个整数变量。

int* p = &x; 将指针p 指向x 的地址。

int* q = &y; 将指针q 指向y 的地址。

p = q; 将指针p 更新为指向q 的地址,即p 现在指向y 的地址。

因此,最终的结果是p 指向了y 的地址,而没有改变x 或y 的值

6. 单选题

在 C++ 中,( )正确定义一个名为 student 的结构体,其中包含一个 name 字符数组和一个 age 整数?

  • A struct student { char name[20]; int age; };
  • B student struct { char name[20]; int age; };
  • C student struct { string name; int age; };
  • D struct student { char[20] name; int age; };
查看答案与解析
答案:A
解析:

A正确地定义了一个名为student 的结构体,包含一个字符数组name 和一个整数age。

B错误,顺序不正确,struct应该在前。

C错误,使用了string,但缺少#include <string>头文件,且结构体定义不正确。

D错误,char[20] name; 语法不正确,应该是char name[20];

7. 单选题

在 C++ 中,( )正确声明了一个 3 行 4 列的二维数组。

  • A int arr[3, 4];
  • B int arr[3][4];
  • C int arr[4][3];
  • D int arr(3, 4);
查看答案与解析
答案:B
解析:

A错误,int arr[3, 4]; 的语法不正确,逗号不应在数组声明中使用。

B正确,int arr[3][4]; 声明了一个3 行4 列的二维数组。

C虽然语法正确,但它声明的是一个4 行3 列的数组,而不是题目中要求的3 行4 列。

D错误,int arr(3, 4); 使用了圆括号,这是错误的语法,不能用于数组声明。

8. 单选题

一个二维数组定义为 int arr[3][4]; (假设一个int变量占4个字节),则 int arr[0] 占用( )个字节的内存。

  • A 3
  • B 4
  • C 12
  • D 16
查看答案与解析
答案:D
解析:

对于定义为int arr[3][4]; 的二维数组,其中每个int 变量占用4 个字节,int arr[0] 指的是第一行的数组arr[0][0] 到arr[0][3]。

计算:每行有4 个int,每个占4 个字节,因此int arr[0] 占用的内存为4×4=16 字节

9. 单选题

下面代码采用递推算法来实现整数 n 的阶乘 (ni=n×(n−1)×...×2×1),则横线上应填写( )。

int factorial(int n) {
	int result = 1;
	for (int i = 2; i <= n; i++) {
		________________________________ // 在此处填入代码
	}
	return result;
}
  • A result *= i;
  • B result += i;
  • C result *= result;
  • D result += result;
查看答案与解析
答案:A
解析:

阶乘的定义是:n! = n * (n-1) * (n-2) * … * 1。

在循环中,从2 到n,每次应将result 乘以当前的i,所以正确的填入应该是result *= i;。

10. 单选题

在排序算法中,稳定性指的是( )。

  • A 排序后数据不会丢失
  • B 排序后相同元素的相对顺序保持不变
  • C 排序后数据不会被修改
  • D 排序后数据的时间复杂度不变
查看答案与解析
答案:B
解析:

解析:稳定排序算法在排序时,如果有两个相等的元素,排序后这两个元素的相对顺序保持不变。

其他选项的解释不符合稳定性的定义:

A错误,排序后的数据是否丢失与稳定性无关。

C错误,排序后数据可能会被修改(如位置改变)。

D错误,时间复杂度是排序算法的性能指标,与稳定性无关。

因此,正确答案是B

11. 单选题

下面代码实现了冒泡排序函数,则横线上应填写( )。

//交换数组arr的第i个元素和第j个元素
void swap(vector<int> &arr, int i, int j) {
	int tmp = arr[i];
	arr[i] = arr[j];
	arr[j] = tmp;
}

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; // 此轮“冒泡”未交换任何元素
	}
}
  • A for (int j = 0; j < arr.size() - 1; j++)
  • B for (int j = arr.size() - 1; j > 0; j–)
  • C for (int j = 0; j < i; j++)
  • D for (int j = i-1; j <=0; j–)
查看答案与解析
答案:C
解析:

冒泡排序的外层循环遍历数组,从后向前控制需要比较的元素范围。

内层循环for (int j = 0; j < i; j++) 则确保在当前遍历中比较到第i 个元素,保证了在每一轮中较大的元素会逐步“冒泡”到末尾

12. 单选题

上一题算法的时间复杂度为( )。

  • A O(n2)
  • B O(2n)
  • C O(1)
  • D O(n)
查看答案与解析
答案:A
解析:

冒泡排序的时间复杂度是O(n²)

13. 单选题

下面代码实现了插入排序函数(升序),则横线上应填写( )。

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;
	}
}
  • A while (j >= 0 && nums[j] > base)
  • B while (j > 0 && nums[j] > base)
  • C while (j >= 0 && nums[j] < base)
  • D while (j > 0 && nums[j] < base)
查看答案与解析
答案:A
解析:

插入排序的基本思想是将当前元素(base)插入到已排序的部分(nums[0]到nums[i-1])中。

在比较时,如果nums[j] 大于base,就需要将nums[j] 向后移动,以腾出位置来插入base。因此,条件应该是j >= 0(确保不越界)且nums[j] > base

14. 单选题

小杨用文件重定向实现在 log.txt 文件中输出日志,则下面横线上应填写( )。

#include <iostream>
#include <fstream>
#include <string>
using namespace std;

int main() {
	ofstream log_file("log.txt");
	
	streambuf* original_cout = cout.rdbuf();
	cout.rdbuf(log_file.rdbuf());
	
	___________________________________ // 在此处填入代码
	
	cout.rdbuf(original_cout); // 恢复原始的标准输出缓冲区
	return 0;
}
  • A cout << “This output will go to the log file.” << endl;
  • B log_file << “This output will go to the log file.” << endl;
  • C

    cout >> “This output will go to the log file.” >> endl;

  • D

    log_file >> “This output will go to the log file.” >> endl;

查看答案与解析
答案:A
解析:

由于之前的代码将cout 的输出重定向到了log_file,因此使用cout 输出的信息将被写入到log.txt 文件中。

选项A 正确,使用cout,而cout 已经被重定向到log_file。

其他选项不正确:

B错误,因为log_file 是一个文件流,应该通过cout 来输出,不能直接用log_file 来输出。

C错误,>>运算符是用于输入流的,不适用于输出。

D错误,类似于B,log_file不应直接使用>> 来输出

15. 单选题

运行下面的代码,屏幕上将输出( )。

#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;
}
  • A division by zero error result: caught an exception:
  • B result: caught an exception: division by zero error
  • C caught an exception: division by zero error
  • D division by zero error caught an exception: division by zero error
查看答案与解析
答案:C
这道题暂未补解析。

二、判断题

16. 判断题

代码 int a = 10; int* p = &a; 可以正确定义指针和初始化指针。

  • A对
  • B错
查看答案与解析
答案:对
解析:

int* p:这里定义了一个整型指针p。星号* 表示p 是一个指向整型的指针。

&a:&是取地址运算符,它返回变量a 的内存地址。

将&a 赋值给p,意味着p 现在指向a 的地址。

因此,指针p 正确地定义并初始化为指向变量a 的地址

17. 判断题

在 C++ 中,引用传递允许函数修改传递给它的参数的值。

  • A对
  • B错
查看答案与解析
答案:对
解析:

引用传递是C++中的一种参数传递方式,它允许函数直接操作传入的变量。通过使用引用(&),函数可以修改原变量的值,而不是只处理变量的副本。这种方式既高效又灵活

18. 判断题

指针的大小与其所指向的变量的数据类型的大小相同。

  • A对
  • B错
查看答案与解析
答案:错
解析:

指针的大小通常与其所处的系统架构有关(如32 位或64 位),而与其所指向的变量的数据类型大小无关。在64 位系统中,所有指针通常都是8 字节,而在32 位系统中,通常是4 字节

19. 判断题

二维数组的行的大小的必须在定义时确定,列的大小可以动态变化。

  • A对
  • B错
查看答案与解析
答案:错
解析:

在C++中,二维数组的行和列的大小都必须在定义时确定,不能动态变化。行的大小在定义时是固定的,列的大小可以在某些情况下通过动态分配实现,但如果使用标准数组,列的大小也必须是常量。

20. 判断题

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

  • A对
  • B错
查看答案与解析
答案:对
解析:

递推算法通过利用已知的前一个或多个状态来逐步计算当前状态,从而解决问题。这种方法常用于动态规划和分治策略中,通过构建状态转移方程来有效地求解复杂问题。

21. 判断题

选择排序是稳定的排序算法。

  • A对
  • B错
查看答案与解析
答案:错
解析:

选择排序是一种不稳定的排序算法。在选择排序过程中,相同元素的相对位置可能会改变,因此不能保证稳定性

22. 判断题

插入排序的时间复杂度总是比冒泡排序低。

  • A对
  • B错
查看答案与解析
答案:错
解析:

不完全正确。插入排序在最佳情况下(已经排序的数组)时间复杂度为O(n),而冒泡排序在最佳情况下也为O(n)。但在平均和最坏情况下,插入排序的时间复杂度为O(n^2),与冒泡排序相同。因此,不能说插入排序总是比冒泡排序低。

23. 判断题

在 C++ 中,如果没有捕获到异常(没有匹配的 catch 块),程序会继续执行而不会终止。

  • A对
  • B错
查看答案与解析
答案:错
解析:

在C++ 中,如果抛出了异常但没有找到匹配的catch 块来捕获它,程序会调用std::terminate(),导致程序终止。因此,未捕获的异常会导致程序结束,而不是继续执行

24. 判断题

以下代码用递推法求斐波那契数列的第n 项,时间复杂度为指数级。

int fibonacci(int n) {
	if (n == 0) return 0;
	if (n == 1) return 1;
	
	int f0 = 0; // F(0)
	int f1 = 1; // F(1)
	int current;
	
	for (int i = 2; i <= n; i++) {
		current = f0+ f1; // F(n) = F(n-1) + F(n-2)
		f0 = f1;
		f1 = current;
	}
	
	return current;
}
  • A对
  • B错
查看答案与解析
答案:错
解析:

迭代的方式计算斐波那契数列,时间复杂度为线性O(n),而不是指数级O(2^n)

25. 判断题

执行下面C++代码后,输出的是20。

int point(int* p){
	return *p * 2;
}

int main() {
	int a = 10;
	int* p = &a;
	*p = point(p);
	cout << *p << endl;
}
  • A对
  • B错
查看答案与解析
答案:对
解析:

通过指针传递,函数point§ 返回10 * 2 = 20,并将其赋给a,最终输出20

三、简答题

26. 简答题

黑白方块

时间限制:1.0 s

内存限制:512.0 MB

题面描述

小杨有一个n行m 列的网格图,其中每个格子要么是白色,要么是黑色。

小杨想知道网格图中是否存在一个满足如下条件的子矩形:

子矩形由4行4列组成;

子矩形的第1行 和第4行只包含白色格子;

对于子矩形的第2行 和第3行,只有第1个和第4个格子是白色的,其余格子都是黑色的;

请你编写程序帮助小杨判断。

输入格式

第一行包含一个正整数t,代表测试用例组数。

接下来是t组测试用例。对于每组测试用例,一共n+1 行。

第一行包含两个正整数n,m,含义如题面所示。

之后n行,每行一个长度为m的01 串,代表网格图第i行格子的颜色,如果为0,则对应格子为白色,否则为黑色。

输出格式

对于每组测试用例,如果存在,输出 Yes,否则输出 No。


输入样例

3
1 4
0110
5 5
00000
01100
01100
00001
01100
5 5
00000
01100
01110
00001
01100

输出样例

No
Yes
No

满足条件的子矩形形如:

0000
0110
0110
0000

对于全部数据,保证有1≤t≤10,1≤n,m≤100。

查看答案与解析
答案:<pre class="brush:cpp;toolbar:false">#include&lt;bits/stdc++.h&gt; using namespace std; const int N = 110; int w[N][N]; int n,m; int match[4][4]; bool check(int xa,int ya){ for(int i=0;i&lt;4;i++){ for(int j=0;j&lt;4;j++){ if(w[xa+i][ya+j]!=match[i][j]){ return false; } } } return true; } int main(){ int t; cin&gt;&gt;t; for(int i=1;i&lt;3;i++)match[1][i]=match[2][i]=1; while(t--){ cin&gt;&gt;n&gt;&gt;m; for(int i=1;i&lt;=n;i++){ string s; cin&gt;&gt;s; for(int j=1;j&lt;=m;j++){ w[i][j]=s[j-1]-'0'; } } int fl = 0; for(int i=1;i&lt;=n-3;i++){ for(int j=1;j&lt;=m-3;j++){ if(check(i,j)){ fl=1; } } } if(fl)cout&lt;&lt;"Yes\n"; else cout&lt;&lt;"No\n"; } }</pre>
解析:

定义二维数组,存储将要输入的网格数据;

将要匹配的模版矩形初始化,4X4的二维数组;

使用循环遍历网格数据中每一个可能的4X4子矩形,检查从位置(i,j)开始的子矩形是否与之前定义好的模版匹配进行判断,输出结果

27. 简答题

区间排序

时间限制:1.0 s

内存限制:512.0 MB

题面描述

小杨有一个包含n个正整数的序列a。

小杨计划对序列进行多次升序排序,每次升序排序小杨会选择一个区间[l,r](l≤r) 并对区间内所有数字,即al,al+1,...,ar进行升序排序。每次升序排序会在上一次升序排序的结果上进行。

小杨想请你计算出多次升序排序后的序列。

输入格式

第一行包含一个正整数n,含义如题面所示。

第二行包含n个正整数 a1,a2,...,an,代表序列。

第三行包含一个正整数q,代表排序次数。

之后q行,每行包含两个正整数li,ri,代表将区间[li,ri] 内所有数字进行升序排序。 ,

输出格式

输出一行包含n个正整数,代表多次升序排序后的序列。

输入样例

5
3 4 5 2 1
3
4 5
3 4
1 3

输出样例

1 3 4 5 2


第一次升序排序后,序列为[3,4,5,1,2];

第二次升序排序后,序列为[3,4,1,5,2];

第三次升序排序后,序列为[1,3,4,5,2];

对于全部数据,保证有1≤n≤100,1≤ai≤100,1≤q≤100,1≤li≤ri≤n。

查看答案与解析
答案:<pre class="brush:cpp;toolbar:false">#include&lt;bits/stdc++.h&gt; using namespace std; const int N = 1010; int a[N]; int n; void bubbleSort(int l,int r){ bool flag = true; while (flag) { flag = false; for (int i = l; i &lt;r; ++i) { if (a[i] &gt; a[i + 1]) { flag = true; swap(a[i],a[i+1]); } } } } int main(){ cin&gt;&gt;n; for(int i=1;i&lt;=n;i++){ cin&gt;&gt;a[i]; } int q; cin&gt;&gt;q; while(q--){ int l,r; cin&gt;&gt;l&gt;&gt;r; bubbleSort(l,r); } for(int i=1;i&lt;=n;i++){ cout&lt;&lt;a[i]; if(i!=n)cout&lt;&lt;" "; else cout&lt;&lt;"\n"; } }</pre>
解析:

将要排序的数据存储在列表中,初始化定义一个长度为1010的数组,尽可能大的数据,确保在输入规模较大的情况下不会越界

定义排序方法对数据进行排序

处理部分:

存储输入数据

处理需要进行排序的区间操作数q

对选定的l,r区间范围内数据进行排序操作,调用之前定义好的排序方法输出结果