CCF编程能力等级认证GESP—C++4级—20241207

原创已于 2025-07-19 16:58:31 修改 · 1k 阅读

27 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #java #算法 #数据结构 #青少年编程

于 2024-12-09 10:57:03 首次发布

CCF编程能力等级认证(GESP)真题解析同时被 2 个专栏收录

84 篇文章

订阅专栏

C++ - 4级

11 篇文章

订阅专栏

CCF编程能力等级认证GESP—C++4级—20241207

单选题（每题 2 分，共 30 分）
判断题（每题 2 分，共 20 分）
编程题 (每题 25 分，共 50 分)
- Recamán
- 字符排序

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

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

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

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

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

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

正确答案：A
考察知识点：函数定义的语法规则（返回类型、参数列表、函数体）。
函数定义需明确返回类型和参数类型，错误的返回类型或参数声明会导致编译失败，这是函数使用的基础语法。
解析过程：
A选项：返回类型float，参数float x，函数体返回x*x，符合语法规则。
B选项：缺少返回类型；C选项：参数未声明类型；D选项：返回类型void却有返回值，且函数体无有效计算。选A。

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

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

正确答案：B
考察知识点：形参和实参的概念、函数参数类型匹配。
形参是函数定义时的占位符，实参是调用时的具体值，参数类型不匹配会导致编译错误，这是函数调用的核心规则。
解析过程：
n是n_chars的形参，times是实参（B正确）；A选项：times是值传递，函数内修改不影响实参，值仍为5；D选项：参数顺序颠倒（char和int类型不匹配）。选B。

3、给定以下代码，执行下述代码后，变量 a 的值为（）。

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

A. 5
B. 10
C. 15
D. 20

正确答案：B
考察知识点：引用传递的特性（函数修改引用参数会直接影响实参）。
引用是变量的别名，引用传递可避免值传递的副本开销，且能直接修改实参，是C++中高效传参的重要方式。
解析过程：
func(int &x)接收a的引用，x *=2等价于a *=2，a从5变为10。选B。

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;

A. 0.2
B. 0.5
C. 1.2
D. 1.5

正确答案：B
考察知识点：动态数组指针的偏移与访问。
动态数组通过new分配内存，指针偏移后指向不同元素，需注意内存释放前需恢复初始指针，否则会导致内存泄漏。
解析过程：
p_arr初始指向数组首元素（0.2），p_arr +=1后指向第二个元素（0.5），输出p_arr[0]即0.5；p_arr -=1恢复指向首元素后释放内存。选B。

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

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

A. 20 20
B. 20 22
C. 22 20
D. 22 22

正确答案：D
考察知识点：指针解引用修改变量值。
*p是指针指向的变量x的别名，修改*p等价于修改x，这是指针操作的核心功能。
解析过程：
p指向x，*p +=2即x +=2，x变为22，*p也为22。选D。

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

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

B.
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];

正确答案：D
考察知识点：结构体数组的定义与动态分配。
结构体数组定义需指定大小，动态分配需使用指针接收new的返回值，错误的类型匹配会导致编译失败。
解析过程：
D选项：Student students = new Student[20]错误，new返回指针，需用Student *students接收。选D。

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

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

A. 0x7ffee4065824
B. 0x7ffee4065828
C. 0x7ffee406582c
D. 0x7ffee4065830

正确答案：D
考察知识点：二维数组元素的地址计算。
二维数组按行优先存储，元素地址=首地址+（行索引×列数+列索引）×元素大小，这是内存布局的核心考点。
解析过程：
array[1][1]的行索引1、列索引1，偏移量=（1×3+1）×4=16字节（0x10），首地址0x7ffee4065820 + 0x10=0x7ffee4065830。选D。

8、下面（）正确定义二维数组。

A. int a[3][];
B. int a[][];
C. int a[][4];
D. int a[][2] = {{1,2},{1,2},{3,4}};

正确答案：D
考察知识点：二维数组的声明规则（行可省，列不可省）。
C++中二维数组声明时列大小必须显式指定，行大小可由初始化列表推导，错误的维度声明会导致编译错误。
解析过程：
D选项：int a[][2] = {{1,2},{1,2},{3,4}}正确，列大小2固定，行大小由初始化列表推导为3；A/B/C选项列大小未指定。选D。

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

A.
result = f1 + f2;
f1 = f2;
f2 = result;
B.
result += f1 + f2;
f1 = f2;
f2 = result;
C.
result += f1 + f2;
f2 = result;
f1 = f2;
D.
result = f1 + f2;
f2 = result;
f1 = f2;

正确答案：A
考察知识点：递推法实现斐波那契数列（迭代更新前序状态）。
递推法通过迭代计算前序状态的关系，时间复杂度O(n)，远优于递归的O(2ⁿ)，是高效求解的关键。
解析过程：
初始f1=0（f(0)）、f2=1（f(1)），循环中result = f1 + f2（f(i)），更新f1=f2、f2=result，符合斐波那契递推公式。选A。

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

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

正确答案：C
考察知识点：冒泡排序的时间复杂度优化（最优情况O(n)）。
冒泡排序可通过标志位优化，若某趟无交换则提前退出，此时时间复杂度为O(n)，错误认知会导致算法效率误判。
解析过程：
C选项错误，冒泡排序在最优情况（已排序）下时间复杂度为O(n)；A/B/D选项描述正确（插入排序在部分有序时效率更高）。选C。

11、冒泡排序的第一轮操作是从左到右遍历数组，通过两两比较相邻元素，将当前最大的元素移动到末尾。给定数组 arr[]={4, 1, 3, 1, 5, 2}，执行第一轮冒泡排序后数组 arr 中的内容为（）。

A. 1, 4, 3, 1, 5, 2
B. 1, 3, 1, 4, 2, 5
C. 1, 4, 3, 1, 2, 5
D. 4, 1, 3, 1, 5, 2

正确答案：B
考察知识点：冒泡排序第一轮的执行过程（将最大元素移至末尾）。
理解第一轮冒泡的元素交换过程，是掌握“逐层冒泡”逻辑的基础，错误的交换顺序会导致排序结果错误。
解析过程：
原数组[4,1,3,1,5,2]，第一轮比较交换后，最大元素5移至末尾，中间元素调整为[1,3,1,4,2,5]。选B。

12、给定如下代码，其时间复杂度为（）。

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

A. $O(n^2)$
B. $O(2^n)$
C. $O (1)$
D. $O (n)$

正确答案：B
考察知识点：递归函数的时间复杂度分析（指数级增长）。
递归函数若每次调用次数翻倍（如cellRecur(n) = 2*cellRecur(n-1) +1），时间复杂度为O(2ⁿ)，会导致效率极低，需警惕递归滥用。
解析过程：
函数调用次数呈指数增长（n=1时1次，n=2时3次，n=3时7次…），时间复杂度为O(2ⁿ)。选B。

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

A. int base = nums[i], j = i - 1;
B. int base = nums[i], j = i;
C. int base = nums[0], j = i - 1;
D. int base = nums[0], j = i;

正确答案：A
考察知识点：插入排序的初始化步骤（保存基准元素与前驱索引）。
插入排序需保存当前元素（base）并从前驱（j=i-1）开始比较后移，缺少初始化会导致数组越界或逻辑错误。
解析过程：
循环内需先声明base = nums[i]（当前元素）和j = i-1（前驱索引），再进入while循环后移元素。选A。

14、下面哪种方式不能实现将字符串"Welcome to GESP!"输出重定向到文件 log.txt （）。

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

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

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

D.
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);

正确答案：C
考察知识点：文件重定向输出的实现方式。
输出重定向需将cout的缓冲区指向文件，或直接使用文件流对象，否则输出仍会发送到控制台。
解析过程：
C选项仅创建outFile但未重定向cout，cout输出仍在控制台，无法写入文件；A/D选项通过rdbuf重定向，B选项直接使用文件流。选C。

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

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

正确答案：A
考察知识点：异常的抛出与捕获匹配。
异常类型需与catch块类型匹配，runtime_error对象会被catch (const runtime_error &e)捕获，这是异常处理的核心规则。
解析过程：
hmean(10,-10)抛出runtime_error，被第一个catch块捕获，输出e.what()即“Runtime error occurred”。选A。

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

1、在 C++ 中，下面代码可以正确定义指针和初始化指针。

int* ptr;
*ptr = 10;

正确答案：错误
考察知识点：指针未初始化的风险。
未初始化的指针指向随机内存，解引用赋值（*ptr=10）会导致未定义行为（如程序崩溃），是常见的内存错误。
解析过程：
代码int *ptr; *ptr=10;中ptr未初始化，属于野指针操作，错误。

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

正确答案：错误
考察知识点：函数声明与定义的分离。
函数可通过“声明在前，定义在后”的方式使用（如头文件声明，cpp文件定义），无需同时声明和定义，这是模块化编程的基础。
解析过程：
函数只需在调用前声明即可，定义可在后续，错误。

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

正确答案：错误
考察知识点：值传递的特性（无法修改实参）。
值传递时函数接收实参的副本，修改副本不影响实参，只有引用传递或指针传递才能修改实参，混淆传递方式会导致逻辑错误。
解析过程：
值传递无法修改实参，错误。

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

正确答案：错误
二维数组的声明规则（列大小必须显式指定）。
为什么是这样：C++要求二维数组的列大小在声明时确定（如int arr[3][4]），行大小可省略，否则编译器无法计算内存布局。
解析过程：
int arr[3][]未指定列大小，语法错误，错误。

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

正确答案：正确
考察知识点：递推算法的定义。
递推通过初始值和递推公式迭代求解，是动态规划、数学建模的核心思想，正确理解其定义是设计高效算法的基础。
解析过程：
递推的核心是“逐步求解”，描述正确，正确。

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

正确答案：正确
考察知识点：递推关系式的时间复杂度计算。
T(n) = T(n-1) +n展开后为T(n) = 1+2+…+n = n(n+1)/2，时间复杂度为O(n²)，这是算法分析的基础能力。
解析过程：
累加和公式推导结果为O(n²)，正确。

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

正确答案：正确
考察知识点：冒泡排序的优化（最优时间复杂度O(n)）。
冒泡排序加入标志位后，若某趟无交换（数组已排序），可提前退出，此时时间复杂度优化为O(n)，是算法优化的典型案例。
解析过程：
最优情况下（已排序）时间复杂度为O(n)，描述正确，正确。

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

正确答案：正确
冒泡排序和插入排序的稳定性。
为什么是这样：两者在排序过程中，相等元素不会交换位置，相对顺序保持不变，是稳定排序的代表，在多关键字排序中至关重要。
解析过程：
冒泡和插入排序均稳定，正确。

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

正确答案：错误
考察知识点：选择排序的不稳定性。
选择排序通过交换当前元素与最小元素，可能导致相等元素的相对顺序改变（如[2,2,1]排序后变为[1,2,2]），因此不稳定。
解析过程：
选择排序不稳定，错误。

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

正确答案：错误
考察知识点：异常的调用与捕获位置。
函数抛出的异常可在调用链的任意上层捕获，不一定必须在直接调用处的try块中，这是异常传播机制的核心。
解析过程：
异常可在调用链上层捕获，无需一定在try中直接调用，错误。

编程题 (每题 25 分，共 50 分)

Recamán

【问题描述】
小杨最近发现了有趣的 Recamán 数列，这个数列是这样生成的：
数列的第一项 $a_1$ 是1；
如果 $a_{k-1} - k$ 是正整数并且没有在数列中出现过，那么数列的第k项 $a_k$ 为 $a_{k-1} - k$ ，否则为 $a_{k-1}+k$ 。
小杨想知道 Recamán 数列的前n项从小到大排序后的结果。手动计算非常困难，小杨希望你能帮他解决这个问题。
【输入格式】
第一行，一个正整数n。
【输出格式】
一行，n个空格分隔的整数，表示 Recamán 数列的前n项从小到大排序后的结果。
【样例输入 1】
5
【样例输出 1】
1 2 3 6 7
【样例输入 2】
8
【样例输出 2】
1 2 3 6 7 12 13 20
【样例解释】

对于样例1，n = 5

$a_1 = 1$ ;
$a_1 - 2 = -1$ ，不是正整数，因此 $a_2 = a_1 + 2 = 3$
$a_2 - 3 == 0$ ，不是正整数，因此 $a_3 = a_2 + 3 = 6$
$a_3 - 4 = 2$ ，是正整数，且没有在序列中出现过，因此 $a_4 = 2$ ；
$a_4 - 5 = -3$ ，不是正整数，因此 $a_5 = a_4 + 5 = 7$

$a_1, a_2, a_3, a_4, a_5$ 从小到大排序后的结果为1 2 3 6 7。
【数据范围】
对于所有数据点，保证 $\le n \le 3000$ 。

字符排序

【问题描述】
小杨有n个仅包含小写字母的字符串 $s_1, s_2, ..., s_n$ ，小杨想将这些字符串按一定顺序排列后拼接到一起构成字符串t。小杨希望最后构成的字符串t满足：
假设 $t_i$ 为字符串t的第i个字符，对于所有的j < i均有 $t_j \le t_i$ 。两个字符的大小关系与其在字母表中的顺序一致，例如 $e < g < p < s$ 。
小杨想知道是否存在满足条件的字符串排列顺序。
【输入格式】
第一行包含一个正整数T，代表测试数据组数。
对于每组测试数据，第一行包含一个正整数n，含义如题面所示。
之后n行，每行包含一个字符串 $s_i$ 。
【输出格式】
对于每组测试数据，如果存在满足条件的排列顺序，输出 1，否则输出 0。
【样例输入 1】
3
3
aa
ac
de
2
aac
bc
1
gesp
【样例输出 1】
1
0
0
【样例解释】
对于第一组测试数据，一种可行的排列顺序为aa+ac+de，构成的字符串t为aaacde，满足条件