首页 › 题库 › GESP编程能力等级认证 › GESP-C++四级

GESP-C++四级 题库

共 324 道题 ,第 1 / 17 页 · 按题型筛选,点「查看答案」核对解析
1 单选题 适中 GESP编程能力等级认证 ·GESP-C++四级 · 1.1 指针定义

小杨想让指针 p 指向整数变量 x ,正确写法是( )

A
int p = &x;
B
int *p = x;
C
int *p = &x;
D
p = *x;
答案与解析
正确答案:C
定义一个指向整型的指针变量,需使用指针声明语法。获取变量的地址,需使用取地址运算符作用于该变量。将地址赋值给指针变量时,类型必须匹配。指针变量存储的是内存地址,而非值本身。通过间接访问运算符可操作指针所指向的对象。
题目详情
2 单选题 适中 GESP编程能力等级认证 ·GESP-C++四级 · 1.1 指针定义

小杨写了如下的指针接力程序,程序执行完后变量 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
声明整型变量a并初始化为5,定义指针p1指向a的地址,定义指针p2并将p1的值(即a的地址)赋给p2,通过解引用p2访问其所指向的内存位置,并将该位置的值修改为10。
题目详情
3 单选题 适中 GESP编程能力等级认证 ·GESP-C++四级 · 2.1 二维数组

小杨用一个二维数组表示棋盘,其中 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
定义了一个二维数组a,行索引从0开始,列索引也从0开始。访问数组元素需使用方括号语法,先指定行下标,再指定列下标。要获取第2行第3列的值,应使用a[1][2],因为第2行对应下标1,第3列对应下标2。通过输出语句可显示该位置的值。数组初始化时按行主序依次赋值,每个内层花括号对应一行数据。
题目详情
4 单选题 适中 GESP编程能力等级认证 ·GESP-C++四级 · 1.1 指针定义

执行完下面的代码后, *(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在内存中的布局,其按行优先方式连续存储12个整型元素。指针p被初始化为指向arr[0][0]的地址,即数组首元素的地址。表达式*(p + 5)表示从p所指地址开始偏移5个整型大小的位置,并解引用该地址对应的值。由于p指向数组首地址,偏移5个元素后对应原数组中第6个元素(下标从0起始),即arr[1][1]所代表的逻辑位置。arr[1][1]直接通过二维数组下标访问第二行第二列元素。两个表达式均基于同一块连续内存的不同访问方式,计算时需将二维下标转换为一维偏移量或反之。
题目详情
5 单选题 适中 GESP编程能力等级认证 ·GESP-C++四级 · 1.3 引用

执行完下面的代码后, 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
首先确定三维数组的结构:arr[2][3][2]表示两个二维数组,每个二维数组包含三行两列。初始化数据按顺序依次填充各元素。sum初始为0。循环部分未完整给出,但根据常见模式,i、j、k分别遍历第一维、第二维和第三维的索引。循环体内通常通过arr[i][j][k]访问每个元素,并将其值累加到sum中。遍历过程覆盖数组所有元素,每个元素被访问且仅被访问一次。累加操作在线性顺序下逐个进行,最终sum接收所有元素值的总和。
题目详情
6 单选题 适中 GESP编程能力等级认证 ·GESP-C++四级 · 1.3 引用

执行完下面的代码后,输出是( )。

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的作用域层次。函数test内声明的局部变量a会屏蔽外部同名全局变量。每个花括号块形成独立作用域,内部声明的a仅在该块内有效。执行a++操作时,修改的是当前作用域下最近声明的a。离开作用域后,之前的a恢复可见。函数调用结束后,main函数中使用的是全局变量a。输出顺序取决于cout语句的执行次序。
题目详情
7 单选题 适中 GESP编程能力等级认证 ·GESP-C++四级 · 1.1 指针定义

执行完下面的代码后, 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
分析函数参数传递方式:byValue函数接收值传递,形参修改不影响实参;byRef函数接收引用传递,形参绑定实参内存,修改直接影响实参;byPointer函数接收指针,通过解引用访问实参内存地址,修改影响实参。主函数中a传入byValue,其值不改变;b传入byRef,被直接修改;c的地址传入byPointer,通过指针解引用修改原值。各变量是否变化取决于参数传递机制对实参内存的访问与操作方式。
题目详情
8 单选题 适中 GESP编程能力等级认证 ·GESP-C++四级 · 1.1 指针定义

运行如下代码会输出( )。

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
首先定义结构体Point包含两个整型成员x和y,结构体Rectangle包含两个Point类型的成员topLeft和bottomRight。在main函数中,声明Rectangle类型的变量rect并用嵌套初始化列表赋初值:topLeft的x和y被初始化为10,bottomRight的x和y被初始化为20。接着将rect.topLeft.x的值修改为5。然后定义指向Point类型的指针p,并将其指向rect.bottomRight的地址。通过指针p访问其指向对象的y成员,并将其值修改为5。最后计算rect.topLeft.x与rect.bottomRight.y的和。
题目详情
9 单选题 适中 GESP编程能力等级认证 ·GESP-C++四级 · 4.1 函数定义调用

给定函数 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
18
答案与解析
正确答案:B
分析函数定义,识别递归终止条件与递推关系。根据参数 n 的不同取值,判断函数调用自身时的分支路径。追踪每次递归调用传入的参数变化,统计所有到达终止条件的执行路径。结合递归返回值的组合方式,推导出最终返回结果的计算过程。
题目详情
10 单选题 适中 GESP编程能力等级认证 ·GESP-C++四级 · 3.1 结构体定义

对如下4个扑克牌进行排序,

struct Card { 
    int value; 
    char suit; // 花色 
}; 
Card cards[4] = {{5,'A'}, {3,'B'}, {5,'C'}, {3,'D'}};

使用某排序算法按value排序后,结果为: {3,'D'}, {3,'B'}, {5,'A'}, {5,'C'} ,则这个排序算法是稳定的吗?

A
稳定,因为相同 value 的元素相对顺序保持不变
B
不稳定,因为 {3,'D'} 出现在 {3,'B'} 之前
C
无法判断
D
稳定,因为结果是有序的
答案与解析
正确答案:B
比较排序前后相同value元素的相对位置。原数组中{3,'B'}在{3,'D'}之前,若排序后{3,'D'}在{3,'B'}之前,则相同value元素的先后顺序发生变化。稳定排序要求相同关键字的记录在排序后保持原有的相对顺序。通过检查相同value对应的不同suit元素在排序前后的次序是否发生交换,可判断算法是否满足稳定性条件。
题目详情
11 单选题 适中 GESP编程能力等级认证 ·GESP-C++四级 · 3.1 结构体定义

下面的函数 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 (int j = i + 1; j < n; j++) { // 填空内容
            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
函数目标是选出前k名成绩最高的学生,采用选择排序的思想维护已处理部分的最大值位置。外层循环控制当前要放置最大值的位置i,内层循环需在剩余未排序部分查找最大值下标。初始假设位置i为最大值索引,内层循环应从i之后的元素开始比较,即j从i+1起始,遍历至数组末尾。每次比较若发现更大分数,则更新最大值索引。循环条件保证不越界且覆盖所有待比较元素。交换操作将当前轮最大值置于位置i,逐步构建前k个最大元素的有序段。
题目详情
12 单选题 适中 GESP编程能力等级认证 ·GESP-C++四级 · 3.1 结构体定义

某游戏的排行榜系统需要实时更新玩家分数。每次只有一个玩家的分数发生变化,排行榜已经是按分数降序排列的。现在需要将更新后的玩家调整到正确位置。下面的函数 updateRanking() 要实现上述功能,则两处横线上应分别填写( )。

#include <string>
using namespace std;

struct Player { 
  string name; 
  int score; 
 }; 

// 玩家索引playerIdx的分数刚刚更新,需要调整位置 
void updateRanking(Player players[], int size, int playerIdx) { 
  Player updatedPlayer = players[playerIdx]; 

  if (playerIdx > 0 && updatedPlayer.score > players[playerIdx - 1].score) { 
    int i = playerIdx; 
    while (i > 0 && updatedPlayer.score > players[i - 1].score) { // 第一空
      players[i] = players[i - 1]; 
      i--; 
    } 
    players[i] = updatedPlayer; 
  } 
  else if (playerIdx < size - 1 && updatedPlayer.score < players[playerIdx + 1].score) { 
    int i = playerIdx; 
    while (i < size - 1 && updatedPlayer.score < players[i + 1].score) { // 第二空
      players[i] = players[i + 1]; 
      i++; 
    } 
    players[i] = updatedPlayer; 
  } 
}
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
首先确定玩家分数更新后可能的移动方向:若分数高于前一名玩家,则需向前移动;若低于后一名玩家,则需向后移动。在向前调整时,从当前索引开始,逐个比较前方元素,将分数较低的玩家向后移位,直到找到正确插入位置。在向后调整时,从当前索引开始,逐个比较后方元素,将分数较高的玩家向前移位,直到满足排序条件。循环条件需保证数组不越界,并持续判断待插入玩家与相邻玩家的分数关系,以决定是否继续移位。
题目详情
13 单选题 适中 GESP编程能力等级认证 ·GESP-C++四级 · 1.3 引用

给定如下算法,其时间复杂度为( )。

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^2)
C
O(n^3)
D
O(2^n)
答案与解析
正确答案:B
分析算法中循环结构的执行次数与输入规模n的关系。首先确定外层循环的迭代次数,再分析内层操作是否依赖于n或存在嵌套循环。若存在嵌套且内外层均与n线性相关,则总执行次数为n的多项式形式。若每层循环的迭代次数均与n成正比,则时间复杂度由最高次项决定。若无嵌套循环,仅单层线性遍历,则执行次数与n成正比。根据代码中循环层数和每层控制条件判断总体增长趋势。
题目详情
14 单选题 适中 GESP编程能力等级认证 ·GESP-C++四级 · 7.1 文件读写

执行下面 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
程序首先创建一个输出文件流,将字符串写入test.txt文件。随后建立输入文件流读取同一文件。文件写入时未添加额外字符,读取操作从文件起始位置开始获取内容。字符串提取方式决定数据分割形式。输出流与输入流分别独立处理文本数据,中间无其他处理环节介入。整个过程依赖文件流的打开模式及读写函数的行为特性。
题目详情
15 单选题 适中 GESP编程能力等级认证 ·GESP-C++四级 · 1.1 指针定义

执行下面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
分析函数divide的逻辑:当参数b为0时,抛出字符串异常;否则返回a/b的结果。main函数中定义result变量并初始化为0,随后进入try块调用divide(10, 0)。由于b为0,满足if条件,执行throw语句抛出异常。此时函数divide不返回值,控制流立即转移至最近的异常处理机制。后续cout语句位于try块内,但在throw执行后不会被执行。程序能否继续取决于是否存在匹配的catch块进行异常捕获与处理。若无相应catch块,异常未被捕获导致程序终止。
题目详情
16 单选题 适中 GESP编程能力等级认证 ·GESP-C++四级 · 综合练习

运行下面程序后变量 a 的值是( )。

A

42

B

43

C

编译错误

D

不确定

答案与解析
正确答案:B
这道题暂未补解析。
题目详情
17 单选题 适中 GESP编程能力等级认证 ·GESP-C++四级 · 综合练习

以下关于数组的描述中,( )是错误的

A

数组名是一个指针常量

B

随机访问数组的元素方便快捷

C

数组可以像指针一样进行自增操作

D

sizeof(arr) 返回的是整个数组 arr 占用的字节数

答案与解析
正确答案:C
这道题暂未补解析。
题目详情
18 单选题 适中 GESP编程能力等级认证 ·GESP-C++四级 · 1.1 指针定义

给定如下定义的数组 arr ,则 *(*(arr + 1) + 2) 的值是( )。

A

2

B

5

C

4

D

6

答案与解析
正确答案:D
这道题暂未补解析。
题目详情
19 单选题 适中 GESP编程能力等级认证 ·GESP-C++四级 · 综合练习

下面这段代码会输出( )

A

3 5

B

编译失败:定义处少了默认参数

C

运行错误

D

链接失败:未定义引用

答案与解析
正确答案:A
这道题暂未补解析。
题目详情
20 单选题 适中 GESP编程能力等级认证 ·GESP-C++四级 · 综合练习

下面这段代码会输出( )。

A

5 5

B

10 10

C

5 10

D

10 5

答案与解析
正确答案:D
这道题暂未补解析。
题目详情