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

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

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

一、单选题

1. 单选题

执行下面程序后,输出为( )。

int f(int x = 2){ 
    return x * 3; 
} 

int main(){ 
    cout << f() << " " << f(4); 
}
  • A 2 12
  • B 6 12
  • C 6 4
  • D 12 6
查看答案与解析
答案:B
解析: 分析函数f的定义,其参数x具有默认值2,返回x乘以3的结果。主函数中调用cout输出时,需识别表达式求值顺序与函数调用行为。首先确定是否存在对函数f的显式调用及其传入参数;其次分析输出语句中各项表达式的计算方式,包括字面量、运算优先级与结合性。注意输出操作符'<<'的连续使用是否合法,并确认每个被输出值的来源:是函数调用结果、常量还是其他表达式。最后根据程序实际执行流程,依次列出各输出项的生成步骤。
2. 单选题

执行下面代码后,输出为( )。

int main() { 
    int a = 5; 
    int* p = &a; 
    int** q = &p; 
    **q += 7; 
    cout << a << " " << *p; 
}
  • A 5 5
  • B 12 12
  • C 12 5
  • D 5 12
查看答案与解析
答案:B
解析: 声明整型变量a并初始化为5,定义指向a的指针p,再定义指向p的二级指针q。通过解引用q两次访问a的值,并将其增加7。随后输出a和*p的值。
3. 单选题

已知:

int a[3][4] = { 
    {1,2,3,4}, 
    {5,6,7,8}, 
    {9,10,11,12} 
}; 
int (*p)[4] = a;

则表达式 *(*(p + 2) + 1) 的值为( )。

  • A 6
  • B 10
  • C 9
  • D 11
查看答案与解析
答案:B
解析: 1. 理解 a 的类型:a 是一个 3 行 4 列的二维整型数组,内存中按行连续存储。2. 分析 p 的定义:p 是指向含有 4 个整型元素的一维数组的指针,即 p 指向 a 的第 0 行。3. 计算 p + 2:p 偏移 2 个单位,每个单位为 4 个 int 大小,因此 p + 2 指向 a 的第 2 行首地址。4. 计算 *(p + 2):解引用得到第 2 行的首地址所指向的内容,即该行第 0 个元素的地址。5. 计算 (p + 2) + 1:在第 2 行的基础上加 1,指向该行第 1 个元素的地址。6. 计算 *(*(p + 2) + 1):对最终地址解引用,取得对应位置的整数值。
4. 单选题

执行下面程序后,输出为( )。

void fun(int a, int &b, int *c){ 
    a += 1; 
    b += 2; 
    *c += 3; 
} 

int main(){ 
    int x = 1, y = 1, z = 1; 
    fun(x, y, &z); 
    cout << x << " " << y << " " << z; 
}
  • A 2 3 4
  • B 1 3 4
  • C 2 1 4
  • D 1 1 1
查看答案与解析
答案:B
解析: 分析函数fun的参数传递方式:a为值传递,形参变化不影响实参;b为引用传递,形参修改直接作用于实参;c为指针传递,通过解引用可修改实参所指向的内存。在main函数中,x、y、z初始均为1,调用fun时,x传值,y传引用,z取地址传入。函数内对a的操作不影响x;对b的操作直接影响y;对*c的操作修改z的值。函数执行过程中,各参数按其传递机制独立作用于对应变量。
5. 单选题

执行下面程序后输出为( )。

int x = 3; 
void f(int& x){ 
    x += 2; 
} 
int main(){ 
    int x = 10; 
    f(x); 
    cout << x << " " << ::x; 
}
  • A 12 3
  • B 10 5
  • C 12 5
  • D 10 3
查看答案与解析
答案:A
解析: 首先确定变量作用域与引用传递机制。函数f接受一个int类型引用参数,对形参的操作直接影响实参。main函数中定义局部变量x并初始化为10,调用f(x)时将该局部变量x的引用传递给函数。在f内部,通过引用将实参值增加2。随后执行输出语句,依次输出main函数中x的值及全局变量x的值。注意局部变量与全局变量的命名冲突由作用域规则决定访问优先级。
6. 单选题

下列关于结构体初始化的写法,正确的是( )。

  • A
    struct Point { int x, y; };
    Point p = (1,2);
  • B
    struct Point { int x, y; };
    Point p = {1,2};
  • C
    struct Point { int x, y; };
    Point p = new Point(1,2);
  • D
    struct Point { int x, y; };
    Point p = <1,2>;
查看答案与解析
答案:B
解析: 结构体定义后,变量初始化需符合语法规范。圆括号用于函数调用或构造函数调用,不适用于C风格聚合初始化。花括号可用于聚合初始化,前提是按成员声明顺序提供初始值。new操作符用于动态分配内存,返回指针类型,不能直接赋值给非指针变量。未提供初始值且缺少初始化表达式时,语法不完整。初始化形式必须与语言版本允许的规则一致,不依赖隐式构造函数存在与否。
7. 单选题

执行下面代码后输出为( )。

struct S { int a; int b; }; 

void g(S s){ s.a += 10; } 
void h(S& s){ s.b += 10; } 

int main(){ 
    S s{1,2}; 
    g(s); 
    h(s); 
    cout << s.a << " " << s.b; 
}
  • A 11 12
  • B 1 12
  • C 11 2
  • D 1 2
查看答案与解析
答案:B
解析: 分析结构体S的两个成员a和b的初始值。观察函数g接收结构体值参数,形参s是实参的副本,函数内对s.a的修改不影响原对象。函数h接收结构体引用参数,形参s与实参为同一对象,函数内对s.b的修改直接影响原对象。执行顺序为先调用g,再调用h。最后输出结构体s的a和b成员值。
8. 单选题

关于递推算法的描述,正确的是( )。

  • A 递推表现为函数自己调用自己
  • B 递推从已知初值出发,利用递推关系逐步推出后续结果
  • C 递推只能用于指数复杂度问题
  • D 递推一定需要回溯
查看答案与解析
答案:B
解析: 递推是一种通过已知初始条件,依据明确的递推关系,逐次计算后续各项值的计算过程。每一步的结果由前一步或前几步的结果直接推导得出,不涉及函数自我调用机制。该过程适用于多种复杂度的问题,可在常数、线性或更高阶的时间复杂度下实现,具体取决于递推关系的结构和计算方式。递推过程为单向推进,不需要回溯已计算结果或尝试其他路径,也不要求问题具备回溯特性。其核心在于构建正确的递推公式并正确初始化起始值。
9. 单选题

执行 climb(6) 的返回值为( )。

int climb(int n){ 
    if(n <= 2) return n; 
    int a = 1, b = 2, c = 0; 
    for(int i = 3; i <= n; i++){ 
        c = a + b; 
        a = b; 
        b = c; 
    } 
    return c; 
    }
  • A 8
  • B 13
  • C 5
  • D 10
查看答案与解析
答案:B
解析: 函数climb接收整数n。当n小于等于2时,直接返回n。对于n大于2的情况,使用三个变量a、b、c,初始值分别为1、2、0。从i=3开始循环至n(含),每次计算c为a与b之和,随后将a更新为b的值,b更新为c的值。循环结束后返回c。该过程通过迭代实现类似斐波那契数列的递推关系,每一项为前两项之和,起始项为1和2。
10. 单选题

某排序算法对如下数据排序(按 score 升序),则下面关于该排序算法稳定性的描述中,说法正确的是( )。

初始: (90,'A'), (90,'B'), (80,'C'), (90,'D')

排序后: (80,'C'), (90,'A'), (90,'B'), (90,'D')

  • A 不稳定,因为出现了相同分数
  • B 稳定,因为相同 score 的相对顺序保持为 A 在 B 前、B 在 D 前
  • C 不稳定,因为 C 跑到前面了
  • D 无法判断
查看答案与解析
答案:B
解析: 观察排序前后元素的位置变化,重点比较具有相同 score 值的元素之间的相对顺序。若所有相同 score 的元素在排序后仍保持原有的先后关系,则算法在此实例中表现出稳定性。检查每个相同键值(如 score=90)对应的标识符(如 'A', 'B', 'D')在初始与排序后的序列中是否维持原有次序。根据排序结果中这些标识符的排列与输入一致,可推断该算法在处理此数据时未改变等值元素的相对位置。
11. 单选题

下面代码试图把数组按升序进行“插入排序”,横线处应填写( )。

void ins(int a[], int n){ 
    for(int i = 1; i < n; i++){ 
        int   key = a[i]; 
        int j = i-1; 
        while(j >= 0 && __________){ 
          a[j+1] = a[j]; 
          j--; 
        } 
        a[j+1] = key; 
    } 
}
  • A a[j] < key
  • B a[j] > key
  • C a[j+1] > key
  • D a[j] == key
查看答案与解析
答案:B
解析: 插入排序中,当前元素key从已排序部分的末尾开始比较,若前一个元素大于key,则将其后移一位,为key腾出位置。循环继续的条件是索引j未越界且当前比较的元素大于key。当j小于0或当前元素不大于key时,循环终止,此时j+1即为key应插入的位置。因此判断条件需反映a[j]与key之间的大小关系,以决定是否继续后移元素。
12. 单选题

下列代码段的时间复杂度为( )。

int cnt=0; 
for(int i=0; i<n; i++){ 
    for(int j=0; j<n; j++){ 
        if( (i+j) % 3 == 0) cnt++; 
    } 
}
  • A O(n)
  • B O(nlogn)
  • C O(n2)
  • D O(2n)
查看答案与解析
答案:C
这道题暂未补解析。
13. 单选题

下面哪种方式不能实现将字符串 Welcome to 2026! 输出重定向到文件 log.txt ( )。

  • A
    freopen("log.txt", "w", stdout);
    cout << "Welcome to 2026!" << endl;
    fclose(stdout);
  • B
    std::ofstream outFile("log.txt");
    cout << "Welcome to 2026!" << endl;
    outFile.close();
  • C
    ofstream log_file("log.txt");
    streambuf* org_cout = cout.rdbuf();
    cout.rdbuf(log_file.rdbuf());
    cout << "Welcome to 2026!" << endl;
    cout.rdbuf(org_cout);
  • D
    std::ofstream outFile("log.txt");
    outFile << "Welcome to 2026!" << endl;
    outFile.close();
查看答案与解析
答案:B
解析: 分析输出重定向机制时,需考察每种方法如何改变标准输出的目标位置。freopen通过C标准库重新绑定stdout文件指针;ofstream构造文件流对象用于写入数据;直接操作streambuf可替换cout的底层缓冲区,使其指向文件流缓冲区;而仅创建输出文件流但未关联到cout,则不会影响原本发送至标准输出的内容流向。重点在于判断各操作是否真正将原本输出至标准输出的数据引导至文件。
14. 单选题

执行下面程序,输出结果是( )。

int divi(int a,int b){ 
    if(b==0) throw 0; 
    return a/b; 
} 

int main(){ 
    try{ 
        cout << divi(10,0); 
    }catch(const char* msg){ 
        cout << "A"; 
    }catch(int){ 
        cout << "B"; 
    } 
}
  • A A
  • B B
  • C 程序崩溃
  • D 无输出
查看答案与解析
答案:B
解析: 分析程序结构,识别函数divi的异常抛出条件;观察main函数中try块内的函数调用参数;确定实际传递给divi的参数值是否触发异常;判断throw 0语句执行时抛出的异常类型;根据C++异常处理机制,匹配catch块的捕获顺序与异常类型兼容性;确认是否存在能捕获int类型异常的处理块;检查是否有其他catch块可能介入处理。
15. 单选题

下列函数实现排行榜中单个元素的位置调整(类似插入排序的相邻搬移)。当某玩家分数增加,需将其向 前移动时, while 循环的条件应为( )。

struct Player{ int score; }; 
void up(Player players[], int n, int idx){ 
    Player cur = players[idx]; 
    int i = idx; 
    while( ____________________ ){ 
        players[i] = players[i-1]; 
        i--; 
    } 
    players[i] = cur; 
}
  • A i > 0 && cur.score > players[i-1].score
  • B i > 0 && cur.score < players[i-1].score
  • C i < n-1 && cur.score > players[i+1].score
  • D i < n-1 && cur.score < players[i+1].score
查看答案与解析
答案:A
解析: 函数目标是将指定索引处的玩家向前移动,直到其分数不再大于前方玩家。当前元素从原位置取出后,需逐个与前一个元素比较。循环应持续当当前位置索引大于0且当前玩家分数大于前一位置玩家分数时。每轮将前一位置的玩家向后移一位,空出位置供当前玩家插入。索引i初始为指定位置,每次循环前移一位,因此循环条件必须同时保证i不越界且满足分数比较条件。比较对象是当前待插入玩家与已处理部分的相邻前驱元素。

二、判断题

16. 判断题

下面代码执行结束时,变量 a 的值变成 15。

void add10(int &x) { x += 10; } 

int main() { 
    int a = 5; 
    add10(a); 
}
  • A 正确
  • B 错误
查看答案与解析
答案:对
解析: 分析函数参数传递方式,确认形参x是否引用实参a的内存地址;跟踪add10函数调用期间对x的操作是否直接作用于a;检查main函数中a的初始值及add10调用前后其存储单元内容的变化过程;验证+=10操作在x指向a时对该存储单元的修改效果。
17. 判断题

引用一旦绑定某个变量,就不能再绑定其他变量。( )

  • A 正确
  • B 错误
查看答案与解析
答案:对
解析: 分析引用的绑定机制,观察其在初始化时关联变量的过程,检查是否存在重新绑定的操作路径,确认引用与变量之间的关联是否具有唯一性和持续性,追踪整个生命周期内引用所指向的内存地址是否发生变化。
18. 判断题

执行下面代码,输出结果为 5 。

int main() { 
    int a[2][3]; 
    cout << &a[1][2] - &a[0][1] << endl; 
    return 0; 
}
  • A 正确
  • B 错误
查看答案与解析
答案:错
解析: 分析代码结构,确认主函数中是否定义了二维数组a[2][3];检查后续是否存在对数组元素的访问或操作;确认cout语句后输出的内容是否涉及数组特定位置的值;验证输出表达式是否直接或间接产生数值5;考察数组未初始化时默认值情况;判断程序执行流程是否包含显式赋值或隐式计算步骤。
19. 判断题

下面程序可以正常编译并输出 10 。

int calc(int x, int y = 10); 
int calc(int x) { return x * 2; } 
int calc(int x, int y) { return x * y; } 

int main() { 
    cout << calc(5); 
}
  • A 正确
  • B 错误
查看答案与解析
答案:错
解析: 分析函数声明与定义的匹配规则,确定重载函数在调用时的解析过程;检查默认参数在函数声明中的位置及其对函数调用的影响;验证函数调用表达式中实参个数与形参匹配情况;考察多个同名函数在相同作用域下的重载决议机制;确认程序控制流进入哪个函数体执行计算逻辑。
20. 判断题

下面程序执行后输出 2010 。

int x = 10; 
void f() { int x = 20; cout << x; } 

int main() { 
    f(); 
    cout << x; 
}
  • A 正确
  • B 错误
查看答案与解析
答案:对
解析: 分析函数作用域中变量的声明与生命周期;确定局部变量x在函数f内是否覆盖外部同名变量;检查cout输出语句所引用的变量x的作用域位置;确认main函数中两次cout分别访问的是哪个作用域的x;根据C++名称查找规则判断每次输出的实际值来源。
21. 判断题

在 C++ 中,如果声明了一个指针变量但没有显式初始化,该指针会自动被初始化为 nullptr 。

  • A 正确
  • B 错误
查看答案与解析
答案:错
解析: 在C++中,指针变量的初始化行为取决于其存储 duration 和声明位置。具有静态存储 duration 的指针(如全局或静态局部指针)若未显式初始化,则被自动初始化为 nullptr。具有自动存储 duration 的指针(如普通局部指针)若未显式初始化,其值未定义,不保证为 nullptr。具有动态分配的指针不受此规则影响,其指向的内存地址由分配结果决定。该机制由C++语言标准中的零初始化、默认初始化和值初始化规则共同决定,具体行为由对象的类型、生命周期和声明上下文确定。
22. 判断题

下面代码没有语法错误。

struct GameCharacter { 
    string name; 
    int level; 
    float position_x; 
    float position_y;

    struct Equipment { 
        string weapon; 
        int attack_bonus; 
        int defense_bonus; 
    } equipment; 

    struct Skill { 
        string name; 
        int damage; 
    } skills[8]; 
    int skill_count; 
};
  • A 正确
  • B 错误
查看答案与解析
答案:对
解析: 分析结构体定义的嵌套规则;检查内部结构体声明与成员变量的语法合法性;确认数组声明的形式是否符合语言规范;验证标识符命名是否存在冲突或重复;逐层解析复合类型中各成员的数据类型与布局方式;确认结构体定义结束时的分号位置是否正确。
23. 判断题

下面程序能够把 Hello 写入 data.txt 文件中。

ofstream fout("data.txt"); 
cout << "Hello"; 
fout.close();
  • A 正确
  • B 错误
查看答案与解析
答案:错
解析: 分析程序语句序列:首先声明一个 ofstream 对象 fout 并以文件名 'data.txt' 初始化,该操作会创建或清空目标文件并建立输出流连接;随后出现 cout,为标准输出流对象。判断程序是否能将 Hello 写入文件,需确认字符串 'Hello' 是否通过 fout 进行写入操作;若写入操作作用于 cout,则数据进入标准输出而非文件;只有当写入操作明确使用 fout 作为输出流时,数据才会进入 data.txt 文件。程序行为取决于流对象的选择与具体插入运算符的调用目标。
24. 判断题

由于选择排序和插入排序的时间复杂度均为 ,在任何实际场景下两者的性能表现几乎相同,可以互相 替代。

  • A 正确
  • B 错误
查看答案与解析
答案:错
解析: 分析两种排序算法的时间复杂度构成,比较其最坏、平均和最好情况下的比较次数与交换次数。考察数据移动方式:选择排序每轮查找最小值位置后执行一次交换,插入排序每轮将当前元素插入已排序部分的适当位置,可能涉及多个元素的位移。对比实际执行的操作数量随输入规模的变化趋势,评估相同时间复杂度下常数因子差异对运行时间的影响。考察输入数据分布对两者操作频次的影响,包括已排序、逆序和随机排列等情况下的行为差异。
25. 判断题

下面用递推方式计算斐波那契数列第 n 项的程序,时间复杂度是O(2n)

int fib(int n) { 
    if (n <= 1) return n; 
    int f0 = 0, f1 = 1, cur = 0; 
    for (int i = 2; i <= n; i++) { 
         cur = f0 + f1; 
         f0 = f1; 
         f1 = cur; 
    } 
    return cur; 
}


  • A 正确
  • B 错误
查看答案与解析
答案:错
这道题暂未补解析。

三、简答题

26. 简答题

山之谷

查看答案与解析
答案:<pre class="brush:cpp;toolbar:false">#include &lt;iostream&gt; using namespace std; int main() {     int n, m;     int h[105][105];     cin &gt;&gt; n &gt;&gt; m;     for (int i = 1; i &lt;= n; i++) {         for (int j = 1; j &lt;= m; j++) {             cin &gt;&gt; h[i][j];         }     }     for (int i = 0; i &lt;= max(n, m) + 1; i++) {         h[i][0] = h[0][i] = h[i][m + 1] = h[n + 1][i] = 1e9;     }     int ans = 0;     for (int i = 1; i &lt;= n; i++) {         for (int j = 1; j &lt;= m; j++) {             bool ok = true;             for (int i2 = i - 1; i2 &lt;= i + 1; i2++) {                 for (int j2 = j - 1; j2 &lt;= j + 1; j2++) {                     if (h[i][j] &gt; h[i2][j2]) {                         ok = false;                         break;                     }                 }                 if (!ok) break; // 补充:内层判断失败,直接跳出i2循环(原代码缺少这一行,逻辑有bug!)             }             ans += ok;         }     }     cout &lt;&lt; ans;     return 0; }</pre><p><br/></p>
这道题暂未补解析。
27. 简答题

礼盒排序

查看答案与解析
答案:<pre class="brush:cpp;toolbar:false">#include &lt;iostream&gt; #include &lt;vector&gt; #include &lt;algorithm&gt; using namespace std; struct Combo {     int sum, mx, mn, id; }; bool cmp(const Combo &amp;a, const Combo &amp;b) {     if (a.sum != b.sum)         return a.sum &lt; b.sum;     if (a.mx != b.mx)         return a.mx &lt; b.mx;     if (a.mn != b.mn)         return a.mn &lt; b.mn;     return a.id &lt; b.id; } int main() {     int n, k;     cin &gt;&gt; n &gt;&gt; k;     vector&lt;Combo&gt; v(n);     for (int i = 0; i &lt; n; i++) {         v[i].sum = 0;         v[i].mx = -1;         v[i].mn = 1e9;         v[i].id = i + 1;         for (int j = 0; j &lt; k; j++) {             int x;             cin &gt;&gt; x;             v[i].sum += x;             v[i].mx = max(v[i].mx, x);             v[i].mn = min(v[i].mn, x);         }     }     sort(v.begin(), v.end(), cmp);     for (int i = 0; i &lt; n; i++) {         cout &lt;&lt; v[i].id;         if (i + 1 &lt; n)             cout &lt;&lt; " ";     }     cout &lt;&lt; endl;     return 0; }</pre><p><br/></p>
这道题暂未补解析。