E1087 CCF-GESP编程能力等级认证-C++ -2026-09 CCF-GESP C++四级真题-考试

小杨使用指针修改计数器的值。执行下面程序后，输出结果是（）。

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

关于下面指针声明的说法，正确的是（）。

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

小杨用二维数组记录仓库货物数量。执行下面代码后，变量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);

下面函数用于将一个3 行5 列二维数组的第r 行元素全部加1，横线处正确的形参写法是（）。

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

执行下面程序后，输出结果是（）。

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

执行下面程序后，输出结果是（）。

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 ;
}

小杨定义了结构体数组，并使用指针访问其中的元素。执行下面代码后输出的是（）。

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 ;
}

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

某机器人每次可以向前移动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 ;
}

对一组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 ')

下面代码使用插入排序将数组按升序排列，横线处应填写（）。

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;
	}
}

下面代码的时间复杂度是（）。

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 ;
}

假设文件data .txt 的内容如下：

Blue Sky

执行下面程序后，输出结果是（）。

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

执行下面程序后，输出结果是（）。

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 ;
}

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

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;
	}
}

执行下面程序后，变量a 的值为15。

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

一个函数必须在调用之前既声明又定义。

下面二维数组在内存中按行优先连续存储，因此*(*(a + 1) + 0) 的值为5。

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

执行下面程序后会输出20。

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

下面结构体初始化语句是合法的。

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

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

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

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

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

下面两层循环的时间复杂度是O（n²）。

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

假设文件能够正常打开，下面程序会把Welcome 写入log.txt。

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

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

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