2023年12月GESP4级总复习（C++）

考试注意事项

12月9日(周六) 上午 9.30-11.30 考试，需 9.20 进入考场，座位号见准考证。

准考证于 12月4日17.00—9日08.00 可打印。

需要带：准考证、身份证、纯白草稿纸、中性笔，可都放在一个半透明/透明考试袋中。

12月6日00.00—8日24.00这三天可在官网进行模拟考试。

编程题可输入一行输出一行，不需要额外建数组保存结果！

23年6月9月真题及知识点详解

选择题判断题

15+10，25题。每题2分，共50分！

选择题判断题大多都是在知识点的基础上改编的，以下是正确语术，需朗读熟知：

常识：

①域名是由一串用点分隔的名字来标识互联网上一个计算机或计算机组的名称，考试官网的域名是 gesp.ccf.org.cn ，其中顶级域名是最后面的 .cn 。

② Windows/Linux/Mac是常见电脑（PC）端操作系统软件；Android/ios/鸿蒙是常见的手机端操作系统。计算机安装了操作系统后才能安装使用各种APP， App 通常指“应用软件”。

③ 图灵奖是计算机科学领域的最高奖。

④中国的国家顶级域名是 .cn 。

⑤在内存储器中每个存储单元都被赋予一个唯一的序号，称为 地址 。

⑥ 编译器的主要功能是将源程序翻译成机器指令代码。

⑦用 关键字const声明一个变量， 其值不能被修改。

⑧计算机数据 存储容量的最小单位是 比特（bit）; 最小的存储单位是 字节（Byte）。1024Byte=1KB,1024KB=1MB,1024MB=1GB,1024GB=1TB。1024是2的10次方。

指针：

①指针类似钟表的指针，它会告诉程序数据在内存中的位置。创建指针变量比普通变量多一个星号，指针变量类型与要指向的变量 数据类型保持一致。

②指针变量 保存的是地址！  “&”取地址运算符：用来获取变量的地址。

③ 指针变量大小与其指向的数据类型无关，而 与编译器有关。64位编译器 指针大小：8个字节；32位编译器 指针大小：4个字节。

④指针可以指向任何类型的数据！除基本数据类型也 可以指向指针变量、结构体、数组。

⑤ 指针的作用是通过指针可以找到数据在内存中的位置。

⑥ 指针运算符*：通过指针运算符，获取指针所指向的变量的值

⑦赋值为“NULL”或者“nullptr”的指针变量称为 空指针，空指针指向的内存区域无法访问！

⑧指向结构体变量地址的指针，称为 结构体指针。指针访问成员变量的语法格式：指针名->成员变量名。

⑨ 指针数组是一组指针变量数据。

函数：

①函数的 函数名不可缺少！参数不是必须的！返回值不是必须的！

②自 定义函数不能写在main函数中，可以写在主函数上面或者下面。

③自定义函数可先定义后调用不声明，也可以先声明再调用后定义。

④main函数也称为主函数，是C++程序的入口。一个程序中有且只能有一个main函数。main函数不能被调用。main函数可以书写在任意位置。

⑤参数是传递给函数的信息，可以一个或多个，不能没有参数。 函数定义时，所创建的参数是一个预定义的变量，称为形式参数，简称形参。调用函数时，传递的参数称为实际参数，简称实参。

⑥函数不被调用时，形参不占内存！形参可以是指针、数组。

⑦传递的实参和形参的数据类型不一致，会发生数据类型转换，实参转换成形参类型。

⑧调用时，传递的实参需要和形参个数一致；传入实参的位置和形参的位置一一对应。

⑨函数重载指两个以上的函数，具有相同的函数名，但是形参个数或者类型不同。

⑩return可以在任意位置，也可以没有。作用是将返回值返回给外部，并结束函数。返回值类型指函数返回值的数据类型。当函数没有返回值时，函数需定义为void类型

11、变量的使用范围称为 变量作用域。变量作用域从定义变量开始，到当前所在花括号结束。

12、 全局变量是指定义在函数之外的变量，不被任何函数体{}所包含。全局有效，被所有函数所共用。

13、 局部变量是在一个函数内部定义的变量。局部变量只在当前所在花括号{}内有效，{}外无法访问该变量。 函数执行完毕，局部变量的空间就被释放！

14、 局部优先原则：定义在函数内部的变量名称，会自动屏蔽定义在外部作用域下的相同变量名，优先访问到局部变量！

15、函数调用时，给形参分配内存空间，并把实参的 值传递给形参。c++中函数参数的传递， 默认是以值传递方式进行传递。值传递时，无论形参发生了怎样的改变，都不会影响到实参。

16、 引用是一种特殊类型的变量，可以被认为是另一个变量的别名。格式：数据类型 &引用变量名 = 被引用变量名称;

17、 引用传递：用引用作为形参，在函数调用时发生的参数传递。函数调用时，给形参分配内存空间，存放实参变量地址。

18、 指针参数：用指针作为形参，在函数调用时发生的参数传递。

19、 数组参数：使用数组名作参数，则实参和形参都应该是数组名，并且类型要相同。

20、 常用系统函数(内置函数)有：max(x,y) 返回x,y中较大值；min(x,y) 返回x,y中较小值；swap(x,y) 交换x,y的值；sort() 排序函数

结构体：

①结构体是由多个类型不同（或相同）的数据组合而成的 自定义数据类型。

② 定义结构体的位置与函数不同。自定义函数只能在主函数外，定义结构体可以在主函数外，也可以在主函数内。

③结构体变量 所占内存，是各成员所需内存量的总和。

④定义 结构体数组时，像使用基本类型一样，使用结构体类型定义数组。

⑤在C++语⾔中，可以定义结构体类型的数组变量，定义结构体时 也可以包含数组成员。

数组：

①存储一组相同类型数据的一排空间，是一维数组。数组元素在内存中是 顺序、连续存储的，每个元素都有对应的编号，这个编号称为数组下标， 下标从0开始。数组所占内存等于所有元素所占内c存之和。

②二维数组可以被看作是多个一维数组，三维数组可以看作是多层二维数组。

③无论是多少维数组， 都有其存在的意义。其中的元素在内存中也都是按顺序存放的。

④传值时，二维数组的 行数可以省略。计算机可以自动确定数组a的行数。 列数一定不能省略。

文件操作：

① 文件保存形式有二进制文件(BIN)和文本文件(.txt)

②文件流头文件: #include < fstream> 用于读写文件。f是file的缩写，中文是文件。stream中文是流。引入 后，不需要再引入。

③ ifstream，从文件中读取数据； ofstream，向文件中写入数据

④通过使⽤ ⽂件重定向操作，可以将程序中输出到 cout 的内容输出到⽂件中，这是常⽤的记录程序运⾏⽇志的⽅法之⼀。

⑤由于 文件重定向操作，程序员在使用 C++语言编写程序时无法确定通过cout输出的内容是否会被输出到屏幕上。

异常处理：

①异常是程序在 运行期间产生的问题，比如：除数为 0、内存分配失败、数组越界、文件不存在等

②程序崩溃时系统就会执行默认的操作：终止程序运行!

③充分考虑各种意外情况，并给予恰当处理，称为 异常处理。关键字： try,执行一段有可能存在异常的代码； catch,用于捕获异常； throw,抛出一个异常

④throw关键字会主动抛出一个异常！ try-catch用于 捕获异常，必须配合使用！如果异常未进行处理，那么程序就会中止，try...catch 后面的内容都不会被执行。

⑤如果某段程序中发现了自己不能处理的异常，就可以使用throw<表达式>抛掷这个异常，其中的<表达式>表示异常类型。

⑥ try后可以有多个catch语句，按顺序从上到下依次比对异常类型，一旦执行其中某个，执行完毕则结束整个try-catch语句！

考点1：计算机常识

6.1、  高级语言编写的程序需要经过以下（ D ）操作，可以生成在计算机上运行的

可执行代码。

A. 编辑

B. 保存

C. 调试

D. 编译

9.1 、 ⼈ 们所使用的手机上安装的 App 通常指的是（ B ）。

A. ⼀ 款操作系统

B. ⼀ 款应用软件

C. ⼀ 种通话设备

D. 以上都不对

考点2：指针

① 指针变量p中存储的是内存地址，*p表示指针p指向的内存中的内容。

②指针变量能指向基本类型、数组、结构体、函数、指针

③空指针（NULL/ nullptr）指向的内存是不可以被访问的。

④C++中， 指针变量所占内存的大小无法确定，具体大小可能会因编译器、操作系统和体系结构的不同而有所变化。在常见的情况下，32 位系统上的指针变量大小是 4 字节，64 位系统上的指针变量大小是 8 字节。

6.3、下列关于 C++ 语言中指针的叙述，不正确的是（ C ）。

A. 指针变量中存储的是内存地址。

B. 定义指针变量时必须指定其指向的类型。

C. 指针变量只能指向基本类型变量，不能指向指针变量。

D. 指针变量指向的内存地址不一定能够合法访问。

6.8、 一个变量定义为 int *p = nullptr; ，则下列说法正确的是（ B ）。

A. 该指针变量的类型为 int 。

B. 该指针变量指向的类型为 int 。

C. 该指针变量指向的内存地址是随机的。

D. 访问该指针变量指向的内存会出现编译错误。

6.11、一 个数组定义为 int a[5] = {1, 2, 3, 4, 5};， 一个指针定义为 int * p = &a[2]; ，则执行 a[1] = *p; 后，

数组 a 中的值会变为（ A ）。

A. {1, 3, 3, 4, 5}

B. {2, 2, 3, 4, 5}

C. {1, 2, 2, 4, 5}

D. {1, 2, 3, 4, 5}

9.4 、下列关于 C++ 语 ⾔ 中指针的叙述 ，不正确的是（ D ）。

A. 可以定义指向 int 类型的指针。

B. 可以定义指向 ⾃ 定义结构体类型的指针。

C. ⾃ 定义结构体类型可以包含指针类型的元素。

D. 不能定义指向 void 类型的指针 ，那没有意义。

9.9 、如果 n 为 int 类型的变量， ⼀ 个指针变量定义为 int *p=&n; , 则下列说法正确的是（ B ）。

A. 指针变量 p 的值与变量 n 是相同

B. 指针变量 p 的值与变量 n 的地址是相同的。

C. 指针变量 p 指向的值为 'n' 。

D. 指针变量 p 指向的值与变量 n 的地址是相同的。

考点3：数组

① 数组（包括多维数组）中的元素在内存中必须是连续存放的。如三维[2][3][4]表示 3层4行5列。

② 任何数组都有它存在的意义。

6.4、 下列关于 C++ 语言中数组的叙述，不正确的是（ D ）。

A. 一维数组在内存中一定是连续存放的。

B. 二维数组是一维数组的一维数组。

C. 二维数组中的每个一维数组在内存中都是连续存放的。

D. 二维数组在内存中可以不是连续存放的。

6.7、 一个二维数组定义为 double array[3][10]; ，则这个二维数组占用内存的大小为（ D ）。

A. 30

B. 60

C. 120

D. 240

9.5 、下列关于 C++ 语 ⾔ 中数组的叙述 ，不正确的是（ D ）。

A. 一维数组可以用来表示数列。

B. 二维数组可以用来表示矩阵。

C. 三维数组可以用来表示空间中物体的形状。

D. 世界是三维的 ，所以定义四维数组没有意义。

9.8 、 ⼀ 个二维数组定义为 char array[3][10]; ，则这个二维数组占用内存的大 ⼩为（ B ）。

A. 10

B. 30

C. 32

D. 48

9.10 、 ⼀ 个三维数组定义为 long long array[6][6][6]; ， 则 array[1][2][3] 和array[3][2][1]在内存中的位置相差多少字节？ ( D )

A. 70 字节

B. 198 字节

C. 560 字节

D. 无法确定

9.14 、执 ⾏ 以下 C++ 语 ⾔ 程序后，输出结果是（ D ）。

A. 0

B. 5

C. 55

D. ⽆ 法确定。

考点4：函数

① 函数可以没有参数和返回值，但函数必须要有名字。

②函数调用时如果缺少实参将不能正确运行。

③可 先定义 再调用 不声明；也可 先声明 再调用 后定义；

6.5、 下列关于 C++ 语言中函数的叙述，正确的是（ A ）。

A. 函数必须有名字。

B. 函数必须有参数。

C. 函数必须有返回值。

D. 函数定义必须写在函数调用前。

9.6 、下列关于 C++ 语 ⾔ 中函数的叙述 ，正确的是（ B ）。

A. 函数调用前必须定义。

B. 函数调用时必须提供足够的实际参数。

C. 函数定义前必须声明。

D. 函数声明只能写在函数调用前。

9.7 、下列关于 C++ 语 ⾔ 中函数的叙述 ，不正确的是（ A ）。

A. 两个函数的声明可以相同。

B. 两个函数的局部变量可以重名。

C. 两个函数的参数可以重名。

D. 两个函数可以重名。

考点5：指针、数组、函数的综合运用

6.12、 以下哪个函数声明在调用时可以传递二维数组的名字作为参数？（ A ）

A. void BubbleSort(int a[ ][4]);

B. void BubbleSort(int a[3][ ]);

C. void BubbleSort(int a[ ][ ]);

D. void BubbleSort(int ** a);

6.13、在下列代码的横线处填写（ B ），可以使得输出是 “20 10” 。

A. int x, int y

B. int * x, int * y

C. int a, int b

D. int & a, int & b

9.12 、 ⼀ 个数组定义为 int a[5] = {1, 2, 3, 4, 5}; ， ⼀ 个指针定义为 int * p = &a[2]; ，则执 ⾏ *p = a[1]; 后 ，

数组 a 中的值会变为（ A ）。

A. {1, 2, 2, 4, 5}

B. {1, 3, 3, 4, 5}

C. {1, 2, 3, 3, 5}

D. {1, 2, 4, 4, 5}

9.15 、在下列代码的横线处填写（ C ），完成对有 n 个 int 类型元素的数组array 由 ⼩ 到 ⼤ 排序。

A. int j = 1; j < n; j++

B. int j = 0; j < n; j++

C. int j = 0; j < i - 1; j++

D. int j = 0; j < i; j++

考点6：作用域

6.6、  下列关于 C++ 语言中变量的叙述，正确的是（ D ）。

A. 变量定义后可以一直使用。

B. 两个变量的变量名不能是相同的。

C. 两个变量的变量名可以相同，但它们的类型必须是不同的。

D. 两个变量的变量名可以相同，但它们的作用域必须是不同的。

6.14、  执行以下 C++ 语言程序后，输出结果是（ D ）。

A. 3

B. 30

C. 33

D. 无法确定。

考点7：排序算法

①冒泡排序、插入排序一般是稳定的，而选择排序一般是不稳定的。

② 对包含 n 个元素的数组进 ⾏ 排序 ，冒泡/插入/选择三种排序的平均时间复杂度一般都 是 O(n^2 )。  ^2指平方 。

③以比较作为基本运算， 在 N 个数中找出最大数，最坏情况下所需要的最少的比较次数为N-1。

6.2、 排序算法是稳定的（ Stable Sorting ），就是指排序算法可以保证，在待排序数据中有两个相等记录的关键字 R 和 S （ R 出现在 S 之前），在排序后的列表中 R 也一定在 S 前。下面关于排序稳定性的描述，正确的是（ C ）。

A. 冒泡排序是不稳定的。

B. 插入排序是不稳定的。

C. 选择排序是不稳定的。

D. 以上都不正确。

6.15、  在下列代码的横线处填写（ A ），完成对有 n 个 int 类型元素的数组 array 由小到大排序。

A. array[min] > array[j]

B. array[min] > array[i]

C. min > array[j]

D. min > array[i]

9.3 、对包含 n 个元素的数组进 ⾏ 冒泡排序 ，平均时间复杂度一般为（ C ）。

A.O(n ）

B.O(n log n ）

C.O(n^ 2 )

D. 以上都不正确

考点8：位运算

位运算符作用于位，假设如果 A = 60，且 B = 13。转二进制后：

A=0011 1100        B=0000 1101       

~A=1100 0011        ~B=11110010       

A&B=0000 1100        A|B=0011 1101       

A^B=0011 0001

6.10、  如果 a 为 int 类型的变量，且 a 的值为 6 ，则执行 a &= 3; 之后，a 的值会是（ C ）。

A. 3

B. 9

C. 2

D. 7

解析：

a = 6&3

0000 0110 按位与

0000 0011 后的结果为：

0000 0010 = 2

9.11 、如果 a 为 int 类型的变量，且 a 的值为 6 ，则执 ⾏ a = ~a; 之后， a 的值会是（ C ）。

A. -6

B. 6

C. -7

D. 7

解析：二进制最前面的一位：0为正，1为负

a = ~6

0000 0110 按位取反后的结果为

1111 1001 ，最前面的11代表 -64，后

面 11 1001 的值为 57，所以结果为：

（-64）+ 57 =  -7

考点9：流程图

需要细心，最好在草稿纸上记录每轮循环后变量的变化。

9.2 、下列流程图的输出结果是？ ( A )

A. 9

B. 7

C. 5

D. 11

考点10：文件与异常

13 、下列关于 C++ 语言中异常处理的叙述，正确的是（ A ）。

A. ⼀ 个 try ⼦ 句可以有多个 catch ⼦ 句与之对应。

B. 如果 try ⼦ 句在执 ⾏ 时发 ⽣ 异常 ，就 ⼀ 定会进 ⼊ 某 ⼀ 个 catch ⼦ 句执 ⾏ 。

C. 如果 try ⼦ 句中没有可能发 ⽣ 异常的语句 ，会产 ⽣ 编译错误。

D. catch ⼦ 句处理异常后 ，会重新执 ⾏ 与之对应的 try ⼦ 句。

编程题

共两题，每题25题。共50分！

1、读懂题意

2、结合输入输出想好需要几个功能，需要哪些变量，写在草稿上，确定框架。

注：定义变量时大多初始值为0，乘法运算的初始为1。

可输入一行输出一行，不需要额外建数组保存结果。

6.一、  幸运数

【问题描述】

小明发明了一种 “ 幸运数 ” 。一个正整数，其偶数位不变（个位为第 1 位，十位为第 2 位，以此类推），奇数位做如下变换：将数字乘以 7 ，如果不大于 9 则作为变换结果，否则把结果的各位数相加，如果结果不大于 9 则作为变换结果，否则（结果仍大于 9 ）继续把各位数相加，直到结果不大于 9 ，作为变换结果。变换结束后，把变换结果的各位数相加，如果得到的和是 8 的倍数，则称一开始的正整数为幸运数。

例如， 16347 ：第 1 位为 7 ，乘以 7 结果为 49 ，大于 9 ，各位数相加为 13， 仍大于 9 ，继续各位数相加，最后结果为 4 ；第 3 位为 3 ，变换结果为 3 ；第 5 位为 1 ，变换结果为 7 。最后变化结果为 76344 ，对于结果 76344 其各位数之和为 24 ，是 8 的倍数。因此 16347 是幸运数。

【输入描述】

输入第一行为正整数 ? ，表示有 ? 个待判断的正整数。约定 1 ≤ ? ≤ 20 。从第 2 行开始的 ? 行，每行一个正整数，为待判断的正整数。约定这些正整数小于10 12 。

【输出描述】

输出 ? 行，对应 ? 个正整数是否为幸运数，如是则输出 'T' ，否则输出 'F' 。提示：不需要等到所有输入结束在依次输出，可以输入一个数就判断一个数并输出，再输入下一个数。

【样例输入 1 】

2

16347

76344

【样例输出 1】

T

F

 解析：

【考纲知识点】模拟法 ( 三级 ) ，函数的定义与调用（四级） 

【题目大意】

对正整数的奇数位进行乘以 7 ，进行若干次数位求和小于等于 9 之后，再与偶数位求和，判断结果是否能被 8 整除。

【解题思路】

1. 首先读入所有待判断的正整数，并依次进行判断，注意使用 long long 类型。

2. 接着通过将一个数不停整除 10 来得到它的每一位。

3. 对其中的奇数位按照题目的要求进行变换，偶数位则不变。奇数位的变换可以按题目文字循环处理，也可以找到等价的更简洁的表达式。

4. 累加每一位并判断总和是否能被 8 整除。

注意在解题过程中合理设计和调用函数，可以使得思路更清晰。

#include
using namespace std;
int number(char a){
	if(a<='9')
		return (a-'0');
	return (a-'A'+10);
}
long long F(int k, char str[]){
	int l=strlen(str);
	long long R=0, r=1;
	for(int i=l-1; i>=0; i--){
		R+=r*number(str[i]);
		r*=k;
	}
	return R;
}
int main(){
	int n=0;
	cin>>n;
	for(int i=0; i>k>>str;
		cout<

9.一、 进制转换

问题描述

N 进制数指的是逢 N 进 ⼀ 的计数制。例如， ⼈ 们日常 ⽣ 活中 ⼤ 多使用 ⼗ 进制计数，而计算机底层则⼀ 般使用二进制。除此之外， ⼋ 进制和 ⼗ 六进制在 ⼀ 些场合也是常⽤ 的计数制（ ⼗ 六进制中， ⼀ 般使用字母A 至F表 ⽰⼗⾄⼗ 五；本题中，⼗⼀进制到 ⼗ 五进制也是类似的）。在本题中，我们将给出 N 个不同进制的数。你需要分别把它们转换成 ⼗ 进制数。

提示

对于任意 ⼀ 个 L 位 K 进制数，假设其最右边的数位为第 0 位，最左边的数位为第 L - 1 位，我们只需要将其第 i 位的数码乘以权值 K i ，再将每位的结果相加，即可得到原K 进制数对应的 ⼗ 进制数。下 ⾯ 是两个例 ⼦ ：

1. ⼋ 进制数 1362 对应的 ⼗ 进制数为 1×8^ 3 ＋ 3×8^ 2 ＋ 6×8^ 1 ＋ 2×8^ 0  = 754 ；

2. ⼗ 六进制数 3F0 对应的 ⼗ 进制数为 3×16^ 2 ＋ 15×16^ 1  + 0×16^ 0  = 1008 。

输入描述

输 ⼊ 的第 ⼀⾏ 为 ⼀ 个 ⼗ 进制表示的整数 N 。接下来 N ⾏ ，每 ⾏⼀ 个整数 K ，随后是⼀ 个空格，紧接着是 ⼀ 个 K 进制数，表示需要转换的数。保证所有 K 进制数均由数字和⼤ 写字母组成，且不以 0 开头 。保证 K 进制数合法。保证N ≤ 1000 ；保证 2 ≤ K ≤ 16 。保证所有K 进制数的位数不超过 9 。

输出描述

输出 N 行，每 ⼀ 个十进制数，表 ⽰ 对应 K 进制数的十进制数值。

样例输入1

2

8 1362

16 3F0

样例输出1

754

1008

解析：

【题目大意】

1.有 n 个 k 进制的整数，将它们分别转换成对应的十进制。

【考纲知识点】

1.基本运算、输入输出语句、循环、进制转换的知识。

【解题思路】

1.按题目要求定义好需要的变量，并实现输入；

2.输入 n 行，每行 2 个整数，分别表示进制和要转换的数字；

3.按求十进制方法：按权展开式。

#include
using namespace std;
int number(char a){
	if(a<='9')
		return (a-'0');
	return (a-'A'+10);
}
long long F(int k, char str[]){
	int l=strlen(str);
	long long R=0, r=1;
	for(int i=l-1; i>=0; i--){
		R+=r*number(str[i]);
		r*=k;
	}
	return R;
}
int main(){
	int n=0;
	cin>>n;
	for(int i=0; i>k>>str;
		cout<