CCF GESP C++ 四级 (2026 年 09 月)

一、单选题（每题 2 分，共 30 分）

1. ⼩杨使⽤指针修改计数器的值。执⾏下⾯程序后，输出结果是（ ）

int count = 8;
int *p = &count;
*p += 4;
cout << count << " " << *p;
return 0;

{{ select(1) }}

• 8 8
• 8 12
• 12 12
• 12 8

2. 关于下⾯指针声明的说法，正确的是（ ）

int a = 10;
int b = 20;
const int *p = &a;

{{ select(2) }}

• 可以通过 p 修改 a 的值
• 可以令 p = &b
• p 的指向和所指向的值都不能修改
• p 必须始终指向 a

3. ⼩杨⽤⼆维数组记录仓库货物数量。执⾏下⾯代码后，变量 x 的值是（ ）

int goods[3][4] = {{2, 4, 6, 8}, {10, 12, 14, 16}, {18, 20, 22, 24}};
int (*p)[4] = goods;
int x = *(*(p + 1) + 2);

{{ select(3) }}

• 12
• 14
• 20
• 22

4. 下⾯函数⽤于将⼀个 3 ⾏ 5 列⼆维数组的第 r ⾏元素全部加 1，横线处正确的形参写法是（ ）

/ 11
void addOne(________, int r) {
    for (int j = 0; j < 5; j++) {
        arr[r][j]++;
    }
}

{{ select(4) }}

• int arr[][]
• int **arr
• int arr[][5]
• int arr[5][]

5. 执⾏下⾯程序后，输出结果是（ ） 2 6

int score = 60;
void update(int &score) {
    score += 5;
}
int main() {
    int score = 80;
    update(score);
    cout << score << " " << ::score;
    return 0;
}

{{ select(5) }}

• 85 60
• 80 65
• 85 65
• 80 60

6. 执⾏下⾯程序后，输出结果是（ ） 5 9 13

struct Device {
    int id;
    int state;
};
void reset(Device d) {
    d.state = 0;
}
void start(Device &d) {
    d.state += 1;
}
int main() {
    Device d{7, 2};
    reset(d);
    start(d);
    cout << d.id << " " << d.state;
    return 0;
}

{{ select(6) }}

• 7 0
• 7 1
• 7 2
• 7 3

7. ⼩杨定义了结构体数组，并使⽤指针访问其中的元素。执⾏下⾯代码后输出的是（ ） 5

struct Book {
    string name;
    int pages;
};
int main() {
    Book books[2] = {{"C++", 120}, {"Math", 150}};
    Book *p = books + 1;
    p->pages += 10;
    cout << books[1].name << " " << books[1].pages;
    return 0;
}

{{ select(7) }}

• C++ 120
• Math 150
• Math 160
• C++ 160

8. 关于冒泡排序、插⼊排序和选择排序，下列说法正确的是（ ）

{{ select(8) }}

• 三种排序算法的最坏时间复杂度都是o(n)
• 冒泡排序只能从⼩到⼤排序，不能从⼤到⼩排序
• 插⼊排序每次将⼀个待排序元素插⼊前⾯已经有序的序列中
• 选择排序每轮只需要⽐较⼀次就能确定最⼩元素

9. 某机器⼈每次可以向前移动 1 格或 2 格，到达第 n 格的⽅法数由下⾯函数计算。 ways(6) 的返回值是 （ ）。

int ways(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 b;
}

{{ select(9) }}

• 8
• 10
• 13
• 21

10. 对⼀组 struct student 的学⽣按成绩（ score ）升序排序。排序前后的数据如下。关于该排序的稳定 性，判断正确的是（ ）。 排序前： 排序后：

struct student {
    int score;
    char id;    
};

排序前：

(90, 'A'), (80, 'B'), (90, 'C'), (80, 'D')

排序后：

(80, 'B'), (80, 'D'), (90, 'C'), (90, 'A')

{{ select(10) }}

• 稳定，因为所有成绩已经按升序排列
• 稳定，因为分数相同不会影响排序结果
• 不稳定，因为相同成绩的 (90, 'A') 和 (90, 'C') 的相对顺序发⽣了改变
• ⽆法判断，因为没有给出排序算法的代码

11. 下⾯代码使⽤插⼊排序将数组按升序排列，横线处应填写（ ）

void insertionSort(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;
    }
}

{{ select(11) }}

• a[j] < key
• a[j] > key
• a[j] == key
• a[j + 1] > key

12. 下⾯代码的时间复杂度是（ ） A. B. C. D.

int countPairs(int a[], int n) {
    int cnt = 0;
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (a[i] + a[j] == 100) {
                cnt++;
            }
        }
    }
    return cnt;
}

{{ select(12) }}

• $O(1)$
• $O(n^3)$
• $O(n)$
• $O(n^2)$

13. 假设⽂件 data.txt 的内容如下： 执⾏下⾯程序后，输出结果是（ ）。

Blue Sky

int main() {
    ifstream fin("data.txt");
    string a, b;
    fin >> a >> b;
    cout << b << "-" << a;
    fin.close();
    return 0;
}

{{ select(13) }}

• Blue-Sky
• Sky-Blue
• Blue Sky
• Sky Blue

14. 执⾏下⾯程序后，输出结果是（ ）

int main() {
    try {
        int age = -1;
        if (age < 0)
            throw age;
        cout << "A";
    } catch (const char *msg) {
        cout << "B";
    } catch (int value) {
        cout << "C" << value;
    }
    return 0;
}

{{ select(14) }}

• A
• B
• C-1
• 程序崩溃

15. 下⾯函数使⽤冒泡排序将数组按升序排列。为了在数组已经有序时提前结束，两处横线应分别填写 （ ）。

void bubbleSort(int a[], int n) {
    for (int i = n - 1; i > 0; i--) {
        bool changed = __________;
        for (int j = 0; j < i; j++) {
            if (a[j] > a[j + 1]) {
                int t = a[j];
                a[j] = a[j + 1];
                a[j + 1] = t;
                changed = __________;
            }
        }
        if (!changed)
            break;
    }
}

{{ select(15) }}

• false ， true
• true ， false
• false ， false
• true ， true

二、判断题（每题 2 分，共 20 分）

1. 执⾏下⾯程序后，变量 a 的值为 15

int a = 10;
int *p = &a;
*p += 5;

{{ select(16) }}

• 对
• 错

2. ⼀个函数必须在调⽤之前既声明⼜定义

{{ select(17) }}

• 对
• 错

3. 下⾯⼆维数组在内存中按⾏优先连续存储，因此 ((a + 1) + 0) 的值为 5

int a[2][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}};

{{ select(18) }}

• 对
• 错

4. 执⾏下⾯程序后会输出 20

void change(int x) {
    x = 20;
}
int main() {
    int x = 10;
    change(x);
    cout << x;
    return 0;
}

{{ select(19) }}

• 对
• 错

5. 下⾯结构体初始化语句是合法的

struct Point {
    int x;
    int y;
};
Point p{3, 4};

{{ select(20) }}

• 对
• 错

6. 对于按升序实现的稳定插⼊排序，移动元素的条件通常应为 a[j] >= key ，这样能够保证相等元素的相对 顺序不变。

while (j >= 0 && a[j] >= key) {
    a[j + 1] = a[j];
    j--;
}

{{ select(21) }}

• 对
• 错

7. 下⾯递推程序计算 。当 n = 4 时，返回值为 24

int factorial(int n) {
    int result = 1;
    for (int i = 1; i <= n; i++) {
        result *= i;
    }
    return result;
}

{{ select(22) }}

• 对
• 错

8. 下⾯两层循环的时间复杂度是

for (int i = 0; i < n; i++) {
    for (int j = 1; j < n; j *= 2) {
        cout << i + j;
    }
}

{{ select(23) }}

• 对
• 错

9. 假设⽂件能够正常打开，下⾯程序会把 Welcome 写⼊ log.txt

int main() {
    ofstream fout("log.txt");
    fout << "Welcome";
    fout.close();
    return 0;
}

{{ select(24) }}

• 对
• 错

10. 执⾏下⾯程序时， catch (int e) 能够捕获由 throw "Error" 抛出的异常，因此程序输出 Caught

int main() {
    try {
        throw "Error";
    } catch (int e) {
        cout << "Caught";
    }
    return 0;
}

{{ select(25) }}

• 对
• 错