每周一套 GESP | C++ 四级真题精讲(第4期):2025年12月
- 2026-11-21 08:36:53
算法与证书之间 | 每周一套 GESP
GESP C++ 四级 真题精讲
2025 年 12 月 认证(第 13 次)
指针 · 数组 · 结构体,排序稳定性与文件读写
15 道单选 + 10 道判断 + 2 道编程
这是 2025 年 12 月的 GESP C++ 四级真题(第 13 次认证),也是四级系列的第 4 期。整张卷子只有一条主线:你到底改到了哪块内存。指针 p 指哪儿、二维数组怎么摊平成一维、引用和指针各改谁、结构体里再套结构体怎么访问——前 9 道单选一口气把这条线走完。
中间 3 道是算法常识:稳定性判断、选择前 K 名的循环边界、排行榜相邻搬移、位运算枚举子集的复杂度。最后 2 道落在文件读写:endl 之后的 getline 到底读到什么、throw 出去的类型谁来接。这两题几乎每年都换皮出现,值得当成固定考点背下来。
答案已和官方答案表逐题核对:单选 C C B D B A C A B B B A B D B,判断 √ × √ √ × √ √ × × √,25 题全部一致,无差异。两道编程题:T1《建造》是3×3 窗口枚举 + 最值维护,T2《优先购买》是结构体三关键字排序 + 贪心购买,参考代码 g++ 实测样例全部通过,可直接提交 OJ。
先提醒两个最容易想歪的地方:第 13 题那段位运算代码看着像 O(2ⁿ),其实外层只循环 n 次,答案是 O(n²);判断第 5 题「两个指针相差 8 个字节」是错的,指针相减得到的是元素个数,答案是 2。
本期 90 分钟:25 道客观题 + 2 道编程题全覆盖
学习建议:四级的指针题不用背,全部画图。画一排格子写变量名,格子上方写地址,箭头表示"谁指向谁"。改值的时候顺着箭头走一格,落到哪个格子就改哪个格子。把这张图画顺了,第 1、2、4、7、8 题就是送分题。
1. 取地址与解引用:int *p = &x; 让 p 存 x 的地址;*p 是"顺着地址找过去的那块内存"。所以 *p = 10 和 x = 10 是同一件事。
2. 二维数组是摊平的:int a[3][4]; 在内存里就是连续的 12 个 int,a[i][j] 排在第 i×4+j 个位置。所以 &a[0][0] 加 5 就是 a[1][1]。
3. 三种传参:void f(int x) 是复印件;void f(int& x) 是别名;void f(int* x) 是地址。改原件的只有后两种,而且指针那种在函数里必须写 *x = ...。
4. 作用域遮蔽:内层 {} 里再定义同名变量,内层改的是内层的;出了这个 {},外层那个原封不动。全局变量只有在没有人遮挡时才被看见。
5. 稳定性:排完后相等元素的相对顺序不变才叫稳定。冒泡、插入稳定;选择排序、快速排序(常规写法)不稳定。判断稳定性的方法只有一个:把原序列里相等元素的前后顺序记下来,和结果比。
6. 复杂度的数数法:一层循环跑 n 次就是 O(n),两层嵌套各 n 次就是 O(n²)。别被循环体里的位运算、递归名字骗了——循环跑了几次,才决定复杂度。
7. 文件与异常:fin >> s 遇到空白(空格、换行)就停,并且不吃掉后面的换行;紧跟其后的 getline 读到的是"这一行剩下的部分",常常是空串。catch 按类型匹配:throw "..." 抛的是 const char*,只有 catch(const char*) 接得住。
📝 单选题精讲(每题 2 分,共 30 分)
小杨想让指针 p 指向整数变量 x,正确写法是( )。
A. int p = &x;
B. int *p = x;
C. int *p = &x; ✓
D. p = *x;
答案:C
📌 口诀:左边带星号,右边带 &,中间是同一个类型。写指针先看这两头对不对。
小杨写了如下的指针接力程序,程序执行完后变量 a、*p1 和 *p2 的值分别是( )。
int a = 5;
int* p1 = &a;
int* p2 = p1;
*p2 = 10;
A. 5 10 10
B. 5 10 15
C. 10 10 10 ✓
D. 5 5 10
答案:C
📌 把"指针接力"理解成三把钥匙开同一扇门:谁去改,门后的东西都变了。
小杨用一个二维数组表示棋盘,其中 1 表示有棋子,0 表示没有棋子。他想知道第 2 行第 3 列有没有棋子,可采用的代码是( )。
int a[3][4] = {
{1, 0, 1, 0},
{0, 1, 0, 1},
{1, 1, 0, 0}
};
A. cout << a[1, 2] << endl;
B. cout << a[1][2] << endl; ✓
C. cout << a(1, 2) << endl;
D. cout << a{1}{2} << endl;
答案:B
📌 写二维下标时默念"先行后列、从零起",能避开八成错误。
执行完下面的代码后,*(p + 5) 和 arr[1][1] 的值分别是( )。
int arr[3][4] = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};
int* p = &arr[0][0];
A. 5 6
B. 6 5
C. 5 5
D. 6 6 ✓
答案:D
📌 记住公式:&arr[0][0] + (i×列数 + j) 就是 &arr[i][j]。
执行完下面的代码后,sum 的值是( )。
int arr[2][3][2] = {
{{1,2}, {3,4}, {5,6}},
{{7,8}, {9,10}, {11,12}}
};
int sum = 0;
for(int i = 0; i < 2; i++)
for(int j = 0; j < 3; j++)
for(int k = 0; k < 2; k++)
if((i+j+k) % 2 == 0)
sum += arr[i][j][k];
A. 36
B. 39 ✓
C. 78
D. 30
答案:B
📌 三层循环的题别硬算,先按 i 分组,每组只看 j、k 两个下标,错不了。
执行完下面的代码后,输出是( )。
int a = 1;
void test() {
int a = 2;
{
int a = 3;
a++;
}
a++;
cout << a << " ";
}
int main() {
test();
cout << a;
return 0;
}
A. 3 1 ✓
B. 4 1
C. 3 2
D. 4 2
答案:A
📌 同名变量三层嵌套时,从最内层往外数,谁在哪个 {} 里,改的就是谁。
执行完下面的代码后,a、b 和 c 的值分别是( )。
void byValue(int x) { x = 100; }
void byRef(int& x) { x = 200; }
void byPointer(int* x) { *x = 300; }
int main() {
int a = 1, b = 2, c = 3;
byValue(a);
byRef(b);
byPointer(&c);
return 0;
}
A. 100 200 300
B. 1 2 3
C. 1 200 300 ✓
D. 1 2 300
答案:C
📌 看参数表就够了:有 & 能改,有 * 且带解引用能改,光有类型名就是改不动。
运行如下代码会输出( )。
struct Point {
int x, y;
};
struct Rectangle {
Point topLeft;
Point bottomRight;
};
int main() {
Rectangle rect = {{10, 10}, {20, 20}};
rect.topLeft.x = 5;
Point* p = &rect.bottomRight;
p->y = 5;
cout << rect.topLeft.x
<< rect.bottomRight.y;
return 0;
}
A. 10 ✓
B. 30
C. 15
D. 20
答案:A
📌 含指针成员访问时记住:p->y 等于 (*p).y,别写成 *p.y(. 的优先级更高,会先算 p.y)。
给定函数 climbStairs(int n) 的定义如下,则 climbStairs(5) 返回的值是( )。
int climbStairs(int n) {
if(n <= 2) return n;
int a = 1, b = 2;
for(int i = 3; i <= n; i++) {
int temp = a + b;
a = b;
b = temp;
}
return b;
}
A. 5
B. 8 ✓
C. 13
D. 10
答案:B
📌 递推题最好的办法是列表,不是心算:n 一行、a 一行、b 一行,三行走完就出答案。
对如下 4 张扑克牌进行排序,使用某排序算法按 value 排序后,结果为 {3,'D'}, {3,'B'}, {5,'A'}, {5,'C'},则这个排序算法是稳定的吗?
struct Card {
int value;
char suit;// 花色
};
Card cards[4] = {
{5, 'A'}, {3, 'B'},
{5, 'C'}, {3, 'D'}
};
A. 稳定,因为相同 value 的元素相对顺序保持不变
B. 不稳定,因为 {3,'D'} 出现在 {3,'B'} 之前 ✓
C. 无法判断
D. 稳定,因为结果是有序的
答案:B
📌 判稳定性只做一件事:找相等的那一组,看它们原来的先后有没有变。
下面的函数 selectTopK() 实现从 n 个学生中选出前 k 名成绩最好的学生颁发奖学金(不需要对所有学生完全排序,只需要找出前 k 名),则横线上应填写( )。
struct Student {
string name;
int score;
};
void selectTopK(Student students[],
int n, int k) {
for (int i = 0; i < k; i++) {
int maxIdx = i;
for (____________________) {
if (students[j].score > students[maxIdx].score) {
maxIdx = j;
}
}
if (maxIdx != i) {
Student temp = students[i];
students[i] = students[maxIdx];
students[maxIdx] = temp;
}
}
}
A. int j = 0; j < n; j++
B. int j = i + 1; j < n; j++ ✓
C. int j = i; j < n; j++
D. int j = 1; j <= n; j++
答案:B
📌 选择排序的循环边界记两条:外层 i 到 k-1,内层 j 从 i+1 到 n-1。
某游戏的排行榜系统需要实时更新玩家分数。每次只有一个玩家的分数发生变化,排行榜已经是按分数降序排列的。现在需要将更新后的玩家调整到正确位置。下面的函数 updateRanking() 要实现上述功能,则两处横线上应分别填写( )。
struct Player {
string name;
int score;
};
// 假设玩家 k 的分数刚刚更新,需要调整位置
void updateRanking(Player players[], int size, int k) {
Player u = players[k];
if (k > 0 &&
u.score > players[k - 1].score) {
int i = k;
while (____________________) {
players[i] = players[i - 1];
i--;
}
players[i] = u;
}
else if (k < size - 1 &&
u.score < players[k + 1].score) {
int i = k;
while (____________________) {
players[i] = players[i + 1];
i++;
}
players[i] = u;
}
}
A. i > 0 && updatedPlayer.score > players[i-1].score / i < size-1 && updatedPlayer.score < players[i+1].score ✓
B. i < size-1 && updatedPlayer.score < players[i+1].score / i > 0 && updatedPlayer.score > players[i-1].score
C. i > 0 && updatedPlayer.score < players[i-1].score / i < size-1 && updatedPlayer.score < players[i+1].score
D. i > 0 && updatedPlayer.score < players[i-1].score / i < size-1 && updatedPlayer.score > players[i+1].score
答案:A
📌 升降两个方向的判断像"电梯限位":往上走要先看有没有天花板,往下走先看有没有地板。
给定如下算法,其时间复杂度为( )。
bool f(int arr[], int n, int target) {
for (int i = 0; i < n; i++) {
int sum = 0;
for (int j = 0; j < n; j++) {
if (i & (1 << j)) {
sum += arr[j];
}
}
if (sum == target) return true;
}
return false;
}
A. O(n)
B. O(n²) ✓
C. O(n³)
D. O(2ⁿ)
答案:B
📌 数复杂度只看循环边界:i < n 就是 n 次,i < (1 << n) 才是 2ⁿ 次。
执行下面 C++ 程序,会输出( )。
int main() {
ofstream fout("test.txt");
fout << "Happy" << endl;
fout << "New Year";
fout.close();
ifstream fin("test.txt");
string s1, s2;
fin >> s1;
getline(fin, s2);
fin.close();
cout << s1 << "|" << s2;
return 0;
}
A. Happy|New Year
B. Happy| New Year
C. HappyNew Year|
D. Happy| ✓
答案:D
📌 记住这个经典坑:>> 之后紧跟 getline,先补一句 fin.ignore() 才拿得到下一行。
执行下面 C++ 代码,会输出( )。
int divide(int a, int b) {
if(b == 0) throw "Division by zero";
return a / b;
}
int main() {
int result = 0;
try {
result = divide(10, 0);
cout << "A";
}
catch(const char* msg) {
cout << "B";
result = -1;
}
cout << result;
return 0;
}
A. A0
B. B-1 ✓
C. A10
D. 程序崩溃
答案:B
📌 throw 什么东西,就要有对应类型的 catch 接;没有匹配的 catch,程序才会异常终止(D 错在这里)。
✅ 判断题精讲(每题 2 分,共 20 分)
小杨正在调试他的温度传感器程序,其中变量 x 保存当前温度。下面这段代码运行后,变量 x 的值变成了 8。
int x = 5;
int *p = &x;
*p = *p + 3;
答案:√ 正确
一个结构体不能包含另一个结构体。
答案:× 错误
在 C++ 中,定义如下二维数组:int a[3][4];,数组 a 在内存中是按行优先连续存放的,即 a[0][0]、a[0][1]、a[0][2]、a[0][3] 在内存中是连续的。
答案:√ 正确
执行下面程序后,变量 a 的值会变成 15。
void add(int &x){
x += 10;
}
int a = 5;
add(a);
答案:√ 正确
执行下面的 C++ 代码,会输出 8,因为两个指针地址相差 8 个字节(假设 int 占 4 字节)。
int arr[5] = {1, 2, 3, 4, 5};
int* p1 = arr;
int* p2 = arr + 2;
cout << p2 - p1;// 输出结果
答案:× 错误
考虑用如下递推方式计算斐波那契数列,时间复杂度是 O(n)。
int n = 10;
int f[20];
f[0] = 0;
f[1] = 1;
for (int i = 2; i <= n; i++)
f[i] = f[i - 1] + f[i - 2];
答案:√ 正确
冒泡排序和插入排序都是稳定排序算法。
答案:√ 正确
下面这段代码实现了选择排序算法。
void sort(int a[], int n) {
for (int i = 1; i < n; i++) {
int x = a[i];
int j = i - 1;
while (j >= 0 && a[j] > x) {
a[j + 1] = a[j];
j--;
}
a[j + 1] = x;
}
}
答案:× 错误
下面代码可以正常编译并输出 10。
#include <iostream>
using namespace std;
int calculate(int x, int y = 10);
int main() {
cout << calculate(5);// 调用1
return 0;
}
int calculate(int x, int y) {
return x * y;
}
int calculate(int x) {// 重载函数
return x * 2;
}
答案:× 错误
执行下面代码会输出 100。
int main() {
ofstream fout("data.txt");
fout << 10 << " " << 20 << endl;
fout << 30 << " " << 40;
fout.close();
ifstream fin("data.txt");
int a, b, c, d;
fin >> a >> b >> c >> d;
fin.close();
cout << a + b + c + d;
return 0;
}
答案:√ 正确
💻 编程题精讲(每题 25 分,共 50 分)
题意:给一张 M 行 N 列的地形图,aij 是坐标 (i,j) 的海拔。停机坪是一个 3×3 的区域,要求区域内 9 个点的最大高度与最小高度之差不超过 H。求所有合规区域里,9 个点海拔之和的最大值。范围:1 ≤ M, N ≤ 10³,1 ≤ H ≤ 10⁵,aij ≤ 10⁵,数据保证至少存在一个合规区域。
思路:窗口枚举 + 边扫边维护最值。3×3 的窗口左上角只能落在 (1..M-2, 1..N-2),一共 (M-2)(N-2) 个位置。对每个窗口,遍历它内部的 9 个格子,一边累加 sum,一边更新最大值 mx 和最小值 mn;如果 mx - mn ≤ H,就用 sum 去更新答案。总运算量是 9MN ≈ 9×10⁶,1 秒完全够。
三个易错点:①窗口个数是 (M-2)×(N-2),写成 M-1、M-3 都会漏或多;②最值的初值要取窗口内第一个点,不能图省事写 0(高度可能全为正数,但写成 0 会让 mn 永远为 0,差值直接判定失败);③答案初值写 0 是安全的,因为数据保证至少有一个合规区域。
参考代码(g++ 实测:样例输出 40):
#include <bits/stdc++.h>
using namespace std;
int a[1010][1010];
int main() {
int m, n, h;
cin >> m >> n >> h;
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++)
cin >> a[i][j];
int ans = 0;
for (int i = 1; i + 2 <= m; i++) {
for (int j = 1; j + 2 <= n; j++) {
int mx = a[i][j], mn = a[i][j];
int sum = 0;
for (int x = 0; x < 3; x++) {
for (int y = 0; y < 3; y++) {
int v = a[i + x][j + y];
sum += v;
if (v > mx) mx = v;
if (v < mn) mn = v;
}
}
if (mx - mn <= h && sum > ans)
ans = sum;
}
}
cout << ans << endl;
return 0;
}
样例 1 输入
5 5 35 5 5 5 55 1 5 1 55 5 5 5 55 2 5 2 53 5 5 5 2
样例 1 输出(实测)
40
样例解释:前两行、第 2 行和中间几列里都有 1,只要窗口沾到 1,最大 5 减最小 1 等于 4 > 3,直接淘汰。真正合规的是靠下靠右的三个窗口:左上角在 (3,1) 的那个窗口含 3、2、5,极差 3,和是 40;左上角在 (3,2)、(3,3) 的两个窗口极差也是 3,但和都只有 39。所以答案是 40。
复杂度:时间 O(9MN) ≈ 9×10⁶ 次加法与比较,1 秒内轻松跑完;空间一张 1010×1010 的 int 表约 4 MB,远低于 512 MB。
题意:小 A 有 M 元预算,商店有 N 件商品,每件有商品名 S、价格 P、优先级 V(V 越小越优先)。购买策略:①总是先买优先级最高的;②优先级相同买价格最低的;③优先级和价格都相同买名字字典序最小的。最后按字典序从小到大输出买到的商品名。范围:1 ≤ |S| ≤ 10,1 ≤ M, P ≤ 10⁹,1 ≤ N ≤ 10³,1 ≤ V ≤ 10。
思路:排序 + 一遍贪心。把三档规则写成一个 cmp:先比 V(小的在前),再比 P(小的在前),最后比名字。整张表按这个顺序排好之后,从前往后扫一遍:钱够就买、扣钱,钱不够就跳过继续看下一件——因为排序已经保证了"越靠前越该先买",所以这个贪心不会错。买到的名字最后再单独按字典序排一次输出。
三个易错点:①输出顺序不是购买顺序,题目要求和的是"按字典序",最后必须再 sort 一次名字;②价格和预算最大 10⁹,用 long long 存价格更稳(int 也放得下 10⁹,但扣减过程中别写成 int 减法链);③cmp 里的三个比较要严格按 V → P → name,顺序一换就全错。
参考代码(g++ 实测:样例输出 bus / cab / water):
#include <bits/stdc++.h>
using namespace std;
struct Item {
string name;
long long price;
int pri;
};
bool cmp(const Item& a, const Item& b) {
if (a.pri != b.pri)
return a.pri < b.pri;
if (a.price != b.price)
return a.price < b.price;
return a.name < b.name;
}
int main() {
long long m;
int n;
cin >> m >> n;
vector<Item> it(n);
for (int i = 0; i < n; i++)
cin >> it[i].name >> it[i].price >> it[i].pri;
sort(it.begin(), it.end(), cmp);
vector<string> buy;
for (int i = 0; i < n; i++) {
if (it[i].price <= m) {
m -= it[i].price;
buy.push_back(it[i].name);
}
}
sort(buy.begin(), buy.end());
for (int i = 0; i < (int)buy.size(); i++)
cout << buy[i] << endl;
return 0;
}
样例 1 输入
20 4apple 6 8bus 15 1cab 1 10water 4 8
样例 1 输出(实测)
buscabwater
样例解释:排序后顺序是 bus(V=1) → water(V=8, P=4) → apple(V=8, P=6) → cab(V=10)。开始有 20 元:买 bus 花 15,剩 5;water 要 4,买,剩 1;apple 要 6 买不起,跳过;cab 要 1,买,剩 0。买到的三个名字排序后输出 bus、cab、water。
复杂度:排序 O(N log N),扫描 O(N),N = 10³ 时不到两万次操作;空间 O(N)。
🗂️ 本期答案速查
单选题(每题 2 分,共 30 分)
1.C 2.C 3.B 4.D 5.B 6.A 7.C 8.A
9.B 10.B 11.B 12.A 13.B 14.D 15.B
判断题(每题 2 分,共 20 分)
1.√ 2.× 3.√ 4.√ 5.× 6.√ 7.√ 8.× 9.× 10.√
已与官方答案表逐题核对,25 题全部一致,无差异
这套卷把四级的"内存观"考得很透:指针是地址、引用是别名、二维数组是摊平的一维、结构体可以层层嵌套。把这几句话变成能在纸上画出来的图,前 9 道单选就都不是问题了。后半段的老四样——稳定性、循环边界、复杂度、文件与异常,每年都考,只是换个数、换个变量名。
两道编程题都属于"看懂就能写"的难度:T1 是 3×3 窗口的暴力枚举,考的是最值初值和窗口边界;T2 是结构体多关键字排序加一遍贪心,考的是排序关键字的顺序和输出前要再排一次字典序。把这两份代码原样敲进 OJ 跑一遍,比读十遍解析管用。
下期预告:每周一套,下周同一时间见。做完欢迎在评论区说说你对了几道、哪题踩了坑,都会精选放出。
算法与证书之间 · 小昕 · 每周一套 GESP