GESP认证C++编程真题解析 | 202406 四级
附上汇总帖：GESP认证C++编程真题解析 | 汇总
单选题
第1题
下列代码中，输出结果是（ ）
#include <iostream>
using namespace std;
int func(int x, int y)
{
int a = x, b = y;
int t;
t = a;
a = b;
b = t;
cout << a << " " << b << " ";
}
int main()
{
int c, d;
c = 12;
d = 24;
func(12, 24);
cout << c << " " << d << endl;
}
A. 12 24 24 12
B. 24 12 12 24
C. 12 12 24 24
D. 24 24 12 12
【答案】：B
【解析】
模拟一下func(）函数的过程，可以发现它将变量x和y的值进行了交换，而传入的x、y的分别是12和24，交换之后便是24和12，因此前两个数输出24和12，后两个数字就是顺序输出的c、d的值，也就是12和24。
第2题
下面函数不能正常执行的是（ ）
A.
#include <iostream>
using namespace std;
int func()
{
//...
}
int main()
{
//...
}
B.
#include <iostream>
using namespace std;
int main()
{
func();
}
int func()
{
//...
}
C.
#include <iostream>
using namespace std;
int func()
{
//...
}
int main()
{
func();
}
D.
#include <iostream>
using namespace std;
int func();
int main()
{
func();
}
int func()
{
//...
}
【答案】：B
【解析】
在调用函数之前，应该先定义函数。
第3题
下面程序输出的是（ ）
#include <iostream>
using namespace std;
int func();
int main()
{
int i = 2;
cout << i << endl;
for (int x = 0; x < 1; x++)
{
int i = 10;
cout << i << endl;
}
i = i+1;
cout << i << endl;
{
i = i*i;
cout << i << endl;
}
}
A. 2 2 3 9
B. 2 10 3 9
C. 2 10 11 121
D. 2 10 3 100
【答案】：B
【解析】
注意for循环内部的变量i只作用于for循环内部，因此第二个输出的数应该是10；而第6行的变量i的作用域则不包含for循环内部的部分，因此第3、4个数的值取决于第6行变量i的初始值，模拟计算一下即可。
第4题
假设变量a的地址是0x6ffe14，下面程序的输出是（ ）。
#include <iostream>
using namespace std;
int main()
{
int *p;
int a = 10;
p = &a;
p++;
cout << p << endl;
}
A. 10
B. 0x6ffe14
C. 0x6ffe15
D. 0x6ffe18
【答案】：D
【解析】
一个int变量占4字节，因此当指针p移动到下一个地址时，应当加上对应的字节数4。
第5题
如果下列程序输出的地址是0x6ffe00则cout<<a+1<<endl;输出的是（ ）
#include <iostream>
using namespace std;
int main()
{
int a[2][3] = {0};
cout << a << endl;
}
A. 0x6ffe04
B. 0x6ffe0C
C. 0x6ffe08
D. 0x6ffe00
【答案】：B
【解析】
一个int变量占4字节，而a是一个2*3规模的二维数组，相当于是2个3长度的一维数组； a 的地址是第0个数组的第0个元素的地址，而a+1的地址是第1个数组的第0个元素的地址；中间间隔了3个int变量，因此应当加上对应的总字节数12。
第6题
C++中，关于文件路径说法错误的是（ ）
A. "GESP.txt"：指定与当前工作目录中的程序文件相同目录中的GESP.txt文件
B. "../data/GESP.txt"：指定与当前工作目录中的程序文件上一级目录下的data目录中的GESP.txt文件
C. "./data/GESP.txt"：指定与当前工作目录中的程序文件同级目录下的data 目录中的GESP txt文件
D. "GESP.txt"是绝对路径
【答案】：D
【解析】
当“GESP.txt”文件前面没有其他前置路径的时候，其表示的意思就是与当前工作目录中的程序文件相同目录中的GESP.txt文件
第7题
关于直接插入排序，下列说法错误的是（ ）
A. 插入排序的最好情况是数组已经有序，此时只需要进行 \(n-1\) 次比较，时间复杂度为 \(O(n)\)
B. 最坏情况是数组逆序排序，此时需要进行 \(n(n-1)/2\) 次比较以及 \(n-1\) 次赋值操作（插入）
C. 平均来说插入排序算法的复杂度为 \(O(n^2)\)
D. 空间复杂度上，直接插入法是就地排序，空间复杂度为 \(O(n)\)
【答案】：D
【解析】
就地排序只需要O(1）的额外空间。
第8题
下列程序横线处，应该输入的是（ ）。
#include <iostream>
using namespace std;
int n, a[10001];
void swap(int &a, int &b)
{
int t = a;
a = b;
b = t;
}
int main()
{
cin >> n;
for (int i=1; i<=n; i++)
cin >> a[i];
for (int i=n; i>1; i--)
for (int j=1; j<i; j++)
if (a[j]>a[j+1])
____;
for (int i=1; i<=n; i++)
cout << a[i] << " ";
cout << endl;
return 0;
}
A. swap(a[j], a[j+1]);
B. swap(a[j-1], a[j]);
C. swap(a[j-1], a[j+1]);
D. swap(&a[j-1], &a[j+1]);
【答案】：A
【解析】
考察冒泡排序的过程，不断地把较大的值往后放，因此，如果a[j]>a[j+1]成立，说明a[j]是较大的值，应当通过交换操作来将a[j]换到后面去。
第9题
下面关于递推的说法不正确的是（ ）。
A. 递推表现为自己调用自己
B. 递推是从简单问题出发，一步步的向前发展最终求得问题，最终求得问题。是正向的
C. 递推中，问题的n要求是在计算中确定，不要求计算前就知道n
D. 斐波那契数列可以用递推实现求解
【答案】：A
【解析】
自己调用自己是递归的表现，而不是递推，注意区分。
第10题
关于几种排序算法的说法，下面说法错误的是（ ）。
A. 选择排序不是一个稳定的排序算法
B. 冒泡排序算法不是一种稳定的排序算法
C. 插入排序是一种稳定的排序算法
D. 如果排序前2个相等的数在序列中的前后位置顺序和排序后它们2个的前后位置顺序相同，则称为一种稳定的排序算法
【答案】：B
【解析】
在冒泡排序中，两个元素交换的条件是a[j]>a[j+1]，如果两个元素的值相等，他们并不会发生交换，因此是一种稳定的排序算法。
第11题
数组{45，66，23，1，10，97，52，88，5，33}进行从小到大冒泡排序过程中，第一遍冒泡过后的序列是（ ）。
A. {45，23，1，10，66，52，88，5，33，97}
B. {45，66，1，23，10，97，52，88，5，33}
C. {45，66，23，1，10，52，88，5，33，97}
D. {45，66，23，1，10，97，52，88，33，5}
【答案】：A
【解析】
按照冒泡排序的过程模拟一遍即可，66会被一直交换到97的前面的位置，97会被一直交换到数组末尾的位置。
第12题
下面的排序算法程序中，横线处应该填入的是（ ）。
int a[8] = {2, 3, 4, 5, 6, 2, 3, 1};
for (int i=1; i<8; i++)
{
int key = a[i];
int j = i - 1;
while (a[j]>key && j>=0)
{
____;
j -= 1;
}
a[j+1] = key;
}
A. a[j] = a[j-1];
B. a[j] = a[j+1];
C. a[j+1] = a[j-1];
D. a[j+1] = a[j];
【答案】：D
【解析】
考察插入排序的过程，不断地将a[i]与前面的数字比较，以便找到合适的位置插入进去；因此，在已排好序的部分中，所有比a[i]大的数字都要整体往右移动一个单位；若a[j]比a[i]大，那么它往右移动一个单位之后的位置是j+1，所以应该将a[j]赋值给a[j+1]。
第13题
下面的程序中，如果输入10 0会输出（ ）。
#include <iostream>
using namespace std;
double Division(int a, int b)
{
if (b==0)
throw "Division by zero condition!";
else
return ((double)a / (double)b);
}
void func()
{
int len, time;
cin >> len >> time;
cout << Division(len, time) << endl;
}
int main()
{
try {
func();
}
catch (const char* errmsg)
{
cout << errmsg << endl;
}
catch (const int errmsg)
{
cout << errmsg << endl;
}
return 0;
}
A. Division by zero condition!
B. 0
C. 10
D. 100
【答案】：A
【解析】
输入len=10与time=0，分别传入Division(）函数中的a、b，于是有a=10、b=0，条件b==0成立。
第14题
10条直线，最多可以把平面分为多少个区域（ ）。
A. 55
B. 56
C. 54
D. 58
【答案】：B
【解析】
当第x条直线加入进来的时候，我们总有一种贪心的方法，让这条直线与前面的所有x-1条直线相交，每发生一次相交都会额外产生一个区域，因此会产生x-1个区域，再加上整个平面本身会被分割一次，所以会产生×个区域，于是10条直线能够分割出来的区域数量就是1+2+3+4+5+6+7+8+9+10=55，最后不要忘记整个平面本身最初也有一个区域，所以还要加1，答案是55+1=56。
第15题
下面程序中，如果语句cout<<p<<endl;输出的是0x6ffe000，则cout<<++p<<endl;输出的是（ ）
int x[10][10][10] = {{0}};
int *p;
p = &x[0][0][0];
cout << p << endl;
cout << ++p << endl;
A. 0x6ffe0c
B. 0x6ffe09
C. 0x6ffe06
D. 0x6ffe04
【答案】：D
【解析】
一个int变量占4字节，p指针指向了x数组的首地址，因此，在++p之后，p指针移动到了下一个元素的地址，需要加上对应的int变量的字节数。
判断题
第1题
int& a 和 &a 是一样的，都是取a的地址。
A. 正确
B. 错误
【答案】：B
【解析】
&a是取a的地址，而int& a是引用变量，作用是获取某个变量的“引用”，即给某一个变量起一个别名。
第2题
以下代码不能够正确执行。
#include <iostream>
using namespace std;
int main()
{
int a = 20;
int& ra;
ra = &a;
cout << ra << endl;
}
A. 正确
B. 错误
【答案】：B
【解析】
同上一题，int& ra是引用变量，需要在定义时设置一个初始值。
第3题
引用是一个指针常量。
A. 正确
B. 错误
【答案】：A
【解析】
指针常量指向的内存地址无法修改，而指向的内存地址对应的值可以修改。
第4题
下面程序两个输出结果是一样的
#include <iostream>
using namespace std;
int main()
{
int a[2][3] = {0};
cout << a << endl;
cout << &a[0][0] << endl;
}
A. 正确
B. 错误
【答案】：A
【解析】
输出a即直接输出数组a的首地址，而a[0][0]是数组a的第0个元素，因此&a[0][0]相当于就是去了第0个元素的地址，即首地址。
第5题
函数不可以调用自己。
A. 正确
B. 错误
【答案】：B
【解析】
递归算法的实现就是“函数调用自己”。
第6题
函数参数传递过程中，如果传常量值、常量引用和常量指针都是不能被修改的，它们可以防止函数对实参的值或地址进行修改。
A. 正确
B. 错误
【答案】：A
【解析】
常量无法被修改，因此若想要实参的值不被修改，传入常量即可。
第7题
下面代码输出的值等于0。
#include <iostream>
using namespace std;
int main()
{
int *p = NULL;
cout << p << endl;
}
A. 正确
B. 错误
【答案】：A
【解析】
空指针指向0地址。
第8题
在下面这个程序里，a[i][j]和一个普通的整型变量一样使用。
#include <iostream>
using namespace std;
int main()
{
int a[10][10] = {0};
for (int i=0; i<10; i++)
{
for (int j=0; j<10; j++)
{
if (i==j)
{
a[i][j] = 1;
}
}
}
A. 正确
B. 错误
【答案】：A
【解析】
整型二维数组中的每一个元素都是一个整型变量
第9题
一个一维数组，至少含有一个自然数N，是一个合法的数列。可以在一维数组末尾加入一个自然数M，M不能超过一维数组末尾元素的一半，形成一个新的合法的一维数组，如果N=6，那么可以有6个不同的合法数组。
A. 正确
B. 错误
【答案】：A
【解析】
合法的6个数组分别是{6}、{6，1}、{6，2}、{6，3}、{6，3，1}、{6，2，1}
第10题
插入排序算法中，平均时间复杂度是 \(O(n^2)\)，最坏的情况逆序情况下，达到最大时间复杂度。
A. 正确
B. 错误
【答案】：A
【解析】
在最坏的逆序情况下，每一个元素都会被插入到已排好序部分的最前面。
浙公网安备 33010602011771号