GESP认证C++编程真题解析 | 202603 二级
附上汇总帖：GESP认证C++编程真题解析 | 汇总
单选题
第1题
2026年春节联欢晚会上一个武术表演节目《武 BOT》。节目中多个人形机器人会表演空翻，它们落地可能会有微微踉跄，但都会迅速调整姿态站稳，并适当移动来和前后左右的其他机器人保持原来队列。如果将机器人视作一个计算机系统，那么在该计算机系统中下面哪一项不能作为输入设备（ ）。
A. 检测重心的重力传感器
B. 预装的AI算法程序
C. 接收动作指令的遥控器
D. 拍摄其他机器人的摄像头
【答案】：B
【解析】
A选项（重力传感器）：感知外界物理环境的倾斜角度和重心数据，并输入给大脑芯片，属于输入设备。
C选项页（遥控器）：接收外部人类发送的无线电控制指令，属于输入设备。
D选项（摄像头）：采集外界的视觉图像信息，同样属于典型的输入设备。
B选项（预装的AI算法程序）：属于计算机系统中的软件（Software），它是一段存储在存储器中、由处理器执行的逻辑代码指令。它负责处理数据（如计算如何保持平衡），而不是从外界收集物理信号的硬件实体，因此不能作为输入设备。
第2题
下面代码用来找出输入的N个正整数中最大的一个。如果将代码段用流程图来表示，则 L1 标记的代码行应该使用的图形是（ ）。
int N, max=0, val;
cin >> N;
while(N){
cin >> val;
if(val > max) // L1
max = val;
N--;
}
cout << max;
A. 圆形框
B. 椭圆形框
C. 平行四边形框
D. 菱形框
【答案】：D
【解析】
L1标记的代码行是if(val > max) 。这是一个典型的条件判断语句（分支结构），程序执行到这里时，必须根据条件的真假（True/False 或Yes/No）来决定接下来的执行路径。
图形匹配：在计算机算法流程图中，菱形框被严格规定用于表示逻辑判断、条件比较或分支选择。
第3题
下面 C++ 代码可以执行，有关说法正确的是（ ）。
double PI = 3.1415926;
cout << (PI);
A. 为了方便初学者，cout << (PI) 和 cout << (pi) 效果相同，即变量的大小写不敏感
B. cout << (PI) 修改为 cout << (Pi) 能正常执行
C. 不能用 PI 做变量名，因为要保存圆周率这个常量
D. 将程序中全部 PI 都改写为 Pai ，将能正常执行，不会报错
【答案】：D
【解析】
A选项与B选项：C++是一门严格区分大小写的语言。
C选项：在C++语言标准中，PI并不是系统的"关键字"或"保留字"，它只是一个普普通通的用户自定义名字。
D选项：变量的名字只是一个代号，只要符合 C++的命名规范（由字母、数字、下划线组成，且不以数字开头，不是关键字），叫什么都可以
第4题
下面选择项中，与C++表达式 !(x > 5 && y <= 10) 等价的是（ ）。
A. x <= 5 && y > 10
B. x > 5 || y <= 10
C. x <= 5 || y > 10
D. ! x > 5 && ! y <= 10
【答案】：C
【解析】
x > 5的反面是 x<=5，y <= 10的反面是 y > 10，&&取反后变成||，所以选C。
第5题
某同学执行C++代码 cout << ((0.1 + 0.2) == 0.3) 时输出 0 ，下面最可能的原因是（ ）。
A. C++的 + 运算符在处理小数时存在bug
B. 0.1 、 0.2 和 0.3 在计算机中无法用二进制浮点数精确表示，导致 0.1 + 0.2 的结果与 0.3 存在微小误差
C. == 运算符不能用于比较浮点数，只能用于整数
D. 因为 0.1 + 0.2 的数学结果不等于 0.3
【答案】：B
【解析】
A选项：C++的的加法运算符在规则内正常运行，这不是bug，而是硬件标准的物理限制。错误。
C选项：C++语法完全允许对浮点数使用==运算符（不会报编译错误），只是在逻辑上极度不推荐这样做，因为极其容易因为精度问题得到意料之外的结果，错误。
D选项：在人类数学算术中，0.1+0.2绝对等于0.3，错误。
第6题
下面的 C++ 代码段执行后其输出是（ ）。
tnt = 0;
for (int i = 0; i < 5; i++){
for (int j = 0; j < i; j++)
tnt += 1;
cout << tnt << "#";
}
cout << tnt;
A. 0#1#3#6#10#10
B. 1#2#3#4#5#6#7#8#9#10
C. 10#10
D. 10
【答案】：A
【解析】
内层循环的作用是：当外层跑到第 i 轮时，就给 tnt 累加 i 次。
第1轮（i=0)：内层循环条件 j<0 根本不成立，内层一次都不执行。tnt 保持0。执行外层打印输出：0#。
第2轮（i=1)：内层循环：j 为 0（执行1次），tnt 增加 1，变成 1。执行外层打印输出：1#。
第3轮（i=2)：内层循环 j 为 0, 1（执行2次），tnt 在 1 的基础上增加 2，变成 3。执行外层打印输出：3#。
第4轮（i=3)：内层循环 j 为0, 1, 2（执行3次），tnt 在 3 的基础上增加 3，变成 6。执行外层打印输出：6#。
第5轮（i=4)：内层循环 j 为0, 1, 2, 3（执行4次），tnt 在 6 的基础上增加 4，变成 10。执行外层打印输出：10#。
此时 i 变成 5，不满足 i < 5 的条件，外层大循环彻底结束。
程序跳出循环后，执行最后一句 cout <<tnt;。此时 tnt 的值停留在 10，所以紧接着输出 10（注意这句后面没有#）。
第7题
下面的 C++ 代码执行之后的输出是（ ）。
for ( int i = -2; i < 2; i++)
if (not i % 3)
cout << i << "#";
A. 0#
B. -2#-1#1#
C. -1#0#
D. -2#0#1#
【答案】：A
【解析】
只有当 i%3 的结果为 0 时（也就是能被3整除时），0 在逻辑上代表 false，经过！取反后才会变成 true，从而执行 cout 输出语句。如果不能整除，余数非 0（代表true），取反后就是 false，不会输出。
第8题
下面的 C++ 代码执行后其输出是（ ）。
int cnt = 0, i, j;
for (i =1; i < 5; i++){
for (j =0; j < i; j++)
cout << j << "#";
break;
}
if(i >= 5)
cout << (i*j);
A. 0#0#1#0#1#2#0#1#2#3#12
B. 0#0#1#0#1#2#0#1#2#3#
C. 0#
D. 1#
【答案】：C
【解析】
- 外层循环第 1 轮：i=1，满足1<5，进入循环体。
- 进入内层循环：j 从 0 开始，条件是 j < i（即 j < 1）
- 当 j=0 时，满足 0<1，执行
cout << j << "#";，屏幕输出0# - j 自增变成 1，此时 1<1 条件为假，内层循环立刻结束。
- 当 j=0 时，满足 0<1，执行
- 内层循环刚刚结束，程序往下走，直接迎面撞上了
break;，无条件执行。因此，外层大循环在 i = 1 的时候，就被当场强行终止了。后续的 i=2，3，4根本连出场的机会都没有。 - 程序跳出循环后，执行 if(i >= 5)。此时 i 的值依然停留在刚被打断时的 1。显然 1>=5 为假，所以最后的
cout <<((i*j);根本不会执行。
综上所述，程序从头到尾只在内层循环跑了一次，输出了一个0#。
第9题
下面 C++ 代码执行后其输出是（ ）。
int count = 0;
for (int i = 1; i < 4; i++)
for (int j = 1; j < 5; j++){
if (j == 3)
continue;
if (i == 2)
break;
count += 1;
}
cout << (count);
A. 2
B. 4
C. 6
D. 8
【答案】：C
【解析】
- 第1轮大循环（i=1)：
- j=1：不是3，i 也不等于2，平安通过，count 变成 1。
- j=2：不是3，平安通过，count 变成 2。
- j=3：触发
j==3，执行 continue。跳过本次累加，直接去执行j == 4。 - j=4：不是3，平安通过，count 变成 3。
- 第2轮大循环（i=2)：
- j=1：不是3。但紧接着触发了
i == 2，执行break。 - break 直接把整个内层 j 循环砸碎了。所以当 i=2 时，count 一次都没有增加，直接跳出内层循环，进入下一轮大循环。
- j=1：不是3。但紧接着触发了
- 第3轮大循环（i=3)：
- 一切恢复如初，和 i=1 时的剧情一模一样。
- j=1：平安通过，count 变成 4。
- j=2：平安通过，count 变成 5。
- j=3：触发 continue，跳过。
- j =4：平安通过，count 变成 6。
此时 i 变成4，不满足 i<4 的条件，外层大循环彻底结束。最终输出 count 的值是6。
第10题
下面4个选项中，与下面 C++ 代码段具有相同效果的是（ ）。
i = 0;
while (i < 5){
cout << i;
i += 1;
}
A.
for (i = 0; i < 5; i++)
cout << i;
B.
for (i = 1; i < 5; i++)
cout << i;
C.
for (i = 0; i < 6; i++)
cout << i;
D.
for (i = 1; i < 6; i++)
cout << i;
【答案】：A
【解析】
原 while 结构的初始化是 i=0;，条件判定是 i<5，循环体内先执行 cout << i;，最后的迭代动作是 i+=1；。模拟运行可知，屏幕会依次输出01234。
第11题
下面 C++ 代码执行后输出是（ ）。
int n = 10;
while (n > 0){
n -= 1;
if (n % 3 == 0)
continue;
if (n == 5)
break;
}
cout << n;
A. 0
B. 5
C. 6
D. 7
【答案】：B
【解析】
初始状态：n = 10。满足 n > 0，进入循环。
第 1 轮：n -= 1 变成9。遇到第一个关卡：if (9%3 == 0)，条件成立，执行 continue。直接跳过本轮后面的代码，回到循环开头。
第 2 轮：当前 n = 9，满足 n > 0。n -= 1 变成 8。8 不能被 3 整除，也不等于 5。进入下一轮。
第 3 轮：当前 n = 8，满足 n > 0。n -= 1 变成 7。7 不能被 3 整除，也不等于 5。进入下一轮。
第 4 轮：当前 n = 7，满足 n > 0。n -= 1 变成 6。遇到第一个关卡 if((6 % 3 == 0)，条件成立，执行 continue。跳过本轮剩余代码。
第 5 轮：当前 n = 6，满足 n > 0。n -= 1 变成 5。5 不能被 3 整除，闯过第一关。遇到第二个关卡if (5 == 5)，条件成立，触发 break，程序彻底跳出循环。
输出结果：跳出循环后，执行 cout << n;，此时 n 的值停留在 5。
第12题
下面 C++ 代码段执行后，其输出是（ ）。
int i, j, cnt;
cnt = 0;
for (i = 0; i < 5; i++){
i = -i;
for (j = i; j < -i; j++)
cnt += 1;
i = -i;
}
cout << cnt;
A. 5
B. 15
C. 20
D. 30
【答案】：C
【解析】
第 1 轮（i=0)：i 取反还是 0。内层循环 j 从 0 跑到 <0，条件根本不成立，执行 0 次。i 恢复为 0。外层 i++ 变成 1。
第 2 轮（i=1)：i 取反变成 -1。内层循环 j 从 -1 跑到 <1（即 j 取 -1, 0），执行 2 次。此时 cnt = 2。i 恢复为 1。外层 i++ 变成 2。
第 3 轮（i=2)：i 取反变成 -2。内层循环 j 从 -2 跑到 <2（即 j 取-2, -1, 0, 1），执行4次。此时 cnt = 2 + 4 + 6。i 恢复为 2。外层 i++ 变成 3。
第 4 轮（i=3)：i 取反变成 -3。内层循环 j 从 -3 跑到 ❤️，执行6次。此时 cnt = 6 + 6 = 12。i 恢复为3。外层 i++ 变成 4。
第 5 轮（i=4)：i 取反变成 -4。内层循环 j 从 -4 跑到 <4，执行8次。此时 cnt = 12 + 8 = 20。i 恢复为 4。外层 i++ 变成 5。
外层判断 i < 5（即5 < 5）为假，大循环彻底结束。最终输出 cnt 的值为 20。
第13题
某学校图书馆的借阅卡号由6位整数组成。前5位是顺序编号，第6位是校验码，用于防止输错。校验码规则如下：将前5位数字相加，然后除以10的余数，就是第6位数字。如卡号 123455 的前5位之和为 15 ，除以 10 的余数是5，故第6位为5。下面的C++代码段用于判断卡号是否正确，横线处应填入的代码是（ ）。
cout << "请输入卡号：";
cin >> N;
order_num = N / 10; // 获得前5位顺序号,假设录入一定为6位正整数
check_num = N % 10; // 获得最后一位
tnt = 0; // 保存前5位之和
for (i = 0; i < 5; i++){
________________;
order_num /= 10;
}
if (__________________)
cout << "符合校验规则";
else
cout << "不符合校验规则";
A.
tnt += order_num / 10
tnt / 10 == check_num
B.
tnt += order_num % 10
tnt % 10 == check_num
C.
tnt = order_num / 10 + tnt
tnt % 10 == check_num
D.
tnt = order_num % 10
tnt / 10 == check_num
【答案】：B
【解析】
第一空（数位剥离与累加）：题目要求将前5位数字相加。在 for 循环中，orde_num 初始装着前 5 位数（例如12345）。为了拿到当前的最后一位（5），我们必须使用 order_num % 10。拿到之后，要把它累加到总和变量 tnt 中，所以标准写法是 tnt += order_num % 10（等价于 tnt = tnt + order_num % 10）。随后的 order_num /= 10 会把用过的 5 砍掉，准备下一轮提取 4。
第二空（规则校验）：循环结束后，tnt 已经完美保存了前 5 位数字的总和。题目给定的校验规则是：“前 5 位数字相加，然后除以 10 的余数，就是第 6 位数字“。求除以 10 的余数依然是使用 %10，即 tnt%10。最后用双等号 == 将它与提前截取好的第 6 位数字 check_num 进行比对，即 tnt % 10 == check_num。
第14题
下面的 C++ 代码段正常执行后其输出的数字图形是（ ）。
for (i = 1; i < 5; i++){
for (j = 1; j < i+1; j++)
cout << j;
cout << endl;
}
A.
1
12
123
1234
B.
1
22
333
4444
C.
1
21
321
4321
D.
4
34
234
1234
【答案】：A
【解析】
外层循环 i 从 1 跑到 4（因为 i<5），这意味着图形一共有 4 行。拆解每一行：
- 当 i=1（第1行）：内层循环 j 从 1 跑到 < 1+1（也就是j=1），执行cout << j。屏幕打印出 1。随后换行。
- 当 i=2（第2行）：内层循环 j 从 1 跑到 < 2+1（也就是 j 取1, 2），依次打印 j。屏幕打印出 12。随后换行。
- 当 i=3（第3行）：内层循环 j 从 1 跑到 < 3+1（也就是 j 取1, 2, 3），依次打印 j。屏幕打印出 123。随后换行。
- 当 i=4（第4行）：内层循环 j 从 1 跑到 < 4+1（也就是 j 取1, 2, 3, 4），依次打印 j。屏幕打印出 1234。随后换行。
第15题
某学校举办“校园演讲比赛”，每位选手由8位评委打分（分数为 0~10 的整数），且每位评委必须打分。计分规则：若至少有5位评委给出大于等于6分，则成绩有效，最终得分为所有8位评委的总分；如给出低于6分的评委数量超过5位，则记为0分。以下核心程序段依次输入8个分数，并计算最终得分。横线处应填入（ ）。
total_score = 0; // 所有分数之和
high_count = 0; // ≥6分的评委数量
for (i = 0; i < 8; i++){
cout << "请输入评委分数: ";
cin >> score;
____________________;
if (score >= 6)
________________;
}
if (high_count >= 5)
cout << total_score;
else
cout << 0;
A.
total_score += score
high_count += 1
B.
total_score += score
high_count += score
C.
high_count += 1
total_score += score
D.
total_score *= score
high_count *= 1
【答案】：A
【解析】
cin >> score；：裁判刚刚亮出了他的分数，装在了 score 变量里。
第一空（必做动作）：题目规则要求"最终得分为所有8位评委的总分"。这意味着不管这个分数是高是低，都必须无条件地装进总分篮子 total_score 里。所以这里应该填入累加公式：total_score += score。
if (score >= 6)：到了条件关卡，系统在检查这个裁判给的分数是不是大于等于6分。
第二空（条件动作）：如果满足了及格条件，我们需要做什么？题目需要统计"给出 ≥6 分的评委数量"。注意，这里统计的是"人数（个数）"，而不是分数的总和。所以只需让计数器加1即可，填入：high_count += 1（或者 high_count++）。
判断题
第1题
小明的妈妈最近刚刚给他买了一块电话手表，除了可以看时间，小明也可以用它和妈妈打电话、收发信息，那么可以推测这块手表中装有一款特定操作系统。（ ）
A. 正确
B. 错误
【答案】：A
【解析】
像智能手表、智能电视、甚至现在的智能冰箱和汽车车机，只要具备了复杂的应用交互和通信功能，内部必然装有特定的操作系统。因此，该推测完全合理。
第2题
C++ 语句 cout << ('4' % '2' == '2' * '2' % 2); 执行后的输出是1。（ ）
A. 正确
B. 错误
【答案】：B
【解析】
在C++中，单引号包裹的'4'和'2'是字符。在进行数学运算时，它们会自动转换为对应的ASCII码整数值。
等号左边：'4' % '2'，实际上是 52 mod 50，结果是2。
等号右边：'2' * '2' % 2，实际上是 50 × 50 mod 2，余数是0。
最后变成了判断：2 == 0，这显然是假的（false）。
第3题
下面的 C++ 代码段执行时将报错，因为10是整数类型，a 是布尔类型。由于类型不同，不能进行加法运算。（ ）
bool a = true;
cout << (10 + a);
A. 正确
B. 错误
【答案】：B
【解析】
在C++语言标准中，布尔类型在参与算术加减乘除运算时，编译器会在底层静默地将 true 转换为整数 1，将 false 转换为整数 0。于是，整个算术表达式在底层实际上变成了简单的整数加法：10 + 1，结果11。不会引发任何编译报错或运行报错。
第4题
下面C++代码段执行后将输出 0-3-6-9-。（ ）
for (int i = 0; i < 10; i++){
if (i % 3)
continue;
cout << i << "-";
}
A. 正确
B. 错误
【答案】：A
【解析】
在C++中，if 语句的括号里如果是一个数字，“非0即为真（true)，只有0才是假（false)“。
第5题
执行下面的 C++ 代码段，如果N是基本数据类型，则语句 cout << (N); 将被执行 0 次或无数次（即死循环）。（ ）
cin >> N;
while (N)
cout << (N);
A. 正确
B. 错误
【答案】：A
【解析】
该代码段的命运要么是不进去（0次），要么是进去了出不来（无数次）。题目说法完全符合客观逻辑。
第6题
下面的 C++ 代码段可正常执行，删除 continue 不影响执行效果。（ ）
for (i = 0; i < 10; i++){
i += 1;
continue;
}
cout << (i);
A. 正确
B. 错误
【答案】：A
【解析】
这个 continue 是一个毫无实际作用的“冗余代码”，删掉它对程序的任何执行细节、变量状态和最终输出都不产生任何影响。题目说法完全正确。
第7题
下面的 C++ 代码段用于计算1到N之间且包含N的所有数字中含有的3的个数，如1到40含有14个3，而1到20则只含有2个3。如果将 while (i != 0) 改为 while (abs(i)) ，则执行结果相同。（ ）
cout << "请输入正整数N：";
cin >> N;
cnt = 0; // 保存3的个数
for (k = 1; k < N + 1; k++){
i = k;
while (i != 0){
if (i % 10 == 3)
cnt += 1;
i /= 10;
}
}
cout << cnt;
A. 正确
B. 错误
【答案】：A
【解析】
将条件替换为 abs(i）不会改变循环的起止时机，最终统计出的 cnt 结果完全相同。
第8题
下面的 C++ 代码段执行将不会有输出，因为内层循环 j 总是 0 开始，i * j % 10 == 0 将会被满足，执行 break ，故而 i 小于 10 ，不会满足 if 判断条件。（ ）
for (i = 1; i < 10; i++)
for (j = 0; j < i; j++)
if (i * j % 10 == 0)
break;
if(i >= 10)
cout << (i*j);
A. 正确
B. 错误
【答案】：B
【解析】
跳出大循环后，此时 i 的真实值是 10，j 的值停留在最后一次被打断时的 0。遇到最后的判断语句 if (i >= 10)，10 大于等于 10 显然为真。程序不仅会输出，而且会明确执行 cout << (i*j);（即输出0）。
第9题
下列 C++ 代码执行后将输出 1#4#9¥16#16。（ ）
cnt = 0;
for (i = 1; i < 5; i++){
for (j = 1; j < i + 1; j++)
if (i * j % 10 == 0)
break;
if (j >= i + 1)
cout << (i * j) << "#";
}
if(i >= 5)
cout << (i * j);
A. 正确
B. 错误
【答案】：B
【解析】
真实的完整输出应该是 2#6#12#20#25。
第10题
下面 C++ 代码执行后输出如左图所示，将 " %d" 修改为 "%3d" 即可实现右图输出。（ ）
/*
// 左图 // 右图
1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9
2 4 6 8 10 12 14 16 18 2 4 6 8 10 12 14 16 18
3 6 9 12 15 18 21 24 27 3 6 9 12 15 18 21 24 27
4 8 12 16 20 24 28 32 36 4 8 12 16 20 24 28 32 36
5 10 15 20 25 30 35 40 45 5 10 15 20 25 30 35 40 45
6 12 18 24 30 36 42 48 54 6 12 18 24 30 36 42 48 54
7 14 21 28 35 42 49 56 63 7 14 21 28 35 42 49 56 63
8 16 24 32 40 48 56 64 72 8 16 24 32 40 48 56 64 72
9 18 27 36 45 54 63 72 81 9 18 27 36 45 54 63 72 81
*/
for (i = 1; i < 10; i++){
for (j = 1; j < 10; j++)
printf(" %d", i*j);
printf("\n");
}
A. 正确
B. 错误
【答案】：B
【解析】
printf 函数的格式控制符 %nd 代表“输出宽度为 n 的右对齐十进制整数“。如果时机数字的位数不足 n，编译器会自动在左侧补齐空格；如果超过或等于 n，则按原样输出。
浙公网安备 33010602011771号