第1章 GESP 二级考点总览

🎯 本章学习目标

学完本书全部 9 章内容，你将能够：

✅ 区分 RAM、ROM、CACHE 的功能与特性
✅ 说出计算机网络的分类与 OSI/TCP/IP 模型
✅ 理解 IP 地址格式、私网段、子网掩码的作用
✅ 区分机器语言、汇编语言、高级语言的特点
✅ 理解编译型与解释型语言的区别
✅ 认识流程图六种符号，读懂流程图算结果
✅ 背出 ASCII 码三个锚点（'0'=48、'A'=65、'a'=97）
✅ 熟练进行字符与 ASCII 码的相互转换
✅ 掌握隐式类型转换与强制类型转换的规则
✅ 避开整数除法、截断、bool 转换等常见陷阱
✅ 灵活运用 if-else if 阶梯与嵌套 if 解决多分支问题
✅ 掌握 switch 语句与 case 穿透现象
✅ 理解逻辑运算与短路求值
✅ 熟练使用 while/do-while/for 三种循环
✅ 用嵌套循环打印图形、实现枚举算法
✅ 掌握 break 与 continue 的区别
✅ 运用 abs/sqrt/max/min/rand 等数学函数
✅ 掌握随机数生成与播种的正确写法
✅ 独立完成二级两道编程题（分支+循环+函数综合）

🗺️ 本章知识图谱

GESP二级 C++ 知识体系
├── 计算机基础（选择判断题）
│   ├── 存储器
│   │   ├── RAM / ROM / CACHE 三大特性
│   │   └── 存储层次结构（寄存器→外存）
│   ├── 计算机网络
│   │   ├── 网络分类（LAN/MAN/WAN）
│   │   ├── 拓扑结构（总线/星型/环型/网状）
│   │   ├── OSI七层 vs TCP/IP四层
│   │   ├── 常见协议分层（HTTP/TCP/IP等）
│   │   ├── TCP vs UDP
│   │   └── IP地址与子网划分
│   ├── 程序设计语言
│   │   ├── 机器语言/汇编语言/高级语言
│   │   ├── 编译型 vs 解释型
│   │   └── C++处理流程（编译→链接）
│   ├── 流程图
│   │   ├── 六种符号（起止/处理/判断/IO/流程线/连接点）
│   │   ├── 三种结构（顺序/分支/循环）
│   │   └── 当型vs直到型循环
│   └── ASCII编码
│       ├── 三个锚点（'0'=48, 'A'=65, 'a'=97）
│       ├── 三大规律（连续/差32/差48）
│       └── 字符运算与整型提升
├── 编程语法（选择+编程题）
│   ├── 数据类型转换
│   │   ├── 隐式转换（自动提升）
│   │   ├── 强制转换（C风格/static_cast）
│   │   ├── 整数除法陷阱
│   │   └── bool转换规则
│   ├── 多层分支结构
│   │   ├── if-else if-else阶梯
│   │   ├── 嵌套if与else配对
│   │   ├── 逻辑运算与短路求值
│   │   └── switch与case穿透
│   └── 多层循环语句
│       ├── while / do-while / for
│       ├── 双重循环（外层行、内层列）
│       ├── break / continue
│       └── 三大套路（求和/计数/求最值）
└── 数学函数（编程题工具箱）
    ├── abs / fabs（绝对值）
    ├── sqrt（平方根）
    ├── max / min（最值）
    ├── pow / ceil / floor（了解）
    └── rand / srand（随机数，重点）

一、写在前面

本书是 《GESP 二级备考白皮书》 的 第 1 章（全书总览），先带你把 八大考点 一次看全。

CCF GESP（编程能力等级认证）二级，是考级体系中的第二个台阶。如果说一级解决的是"能不能写出最简单的顺序程序"，那么二级要回答的问题是："程序的逻辑能不能复杂起来？计算机和网络的基本常识你懂不懂？"

从一级到二级，是一次关键的跨越：

🔽 向下：开始接触计算机基础知识——ROM/RAM/CACHE 三种存储器、网络分类、OSI 与 TCP/IP 模型、IP 地址
🔼 向上：程序逻辑从"一条直线"变成"多层路网"——多层分支（if/switch 嵌套）与多层循环（while/do-while/for 嵌套）
🔤 向细：搞懂字符与编码——ASCII 码怎么算、数据类型之间怎么转换
🧮 向实：装备数学函数工具箱——绝对值、平方根、最值、随机数，编程题随取随用

💡 全书规划：本章为总览篇，后续第 2~9 章将逐模块深入拆解，每章独立成篇，覆盖知识点精讲、典型例题、编程实战与备考策略。

二、📊 八大考点全景总表

GESP 二级考纲的 8 大知识模块一览全局：

序号	📌 考点模块	📖 一句话概括	⭐ 考频星级
①	计算机存储与网络	ROM/RAM/CACHE、网络分类、OSI七层与TCP/IP四层、IP地址与子网	⭐⭐⭐⭐
②	程序设计语言	机器语言/汇编语言/高级语言、编译与解释、常见高级语言	⭐⭐⭐
③	流程图	标准符号、绘制流程图、读流程图描述算法	⭐⭐⭐⭐
④	ASCII编码	常用字符的ASCII码、字符与码值相互转换	⭐⭐⭐⭐
⑤	数据类型转换	隐式类型转换、强制类型转换、整数除法截断	⭐⭐⭐⭐
⑥	多层分支结构	if、if...else、switch 的嵌套与 case 穿透	⭐⭐⭐⭐⭐
⑦	多层循环语句	while、do...while、for 的嵌套，break/continue	⭐⭐⭐⭐⭐
⑧	数学函数	abs、sqrt、max、min、rand/srand 随机数	⭐⭐⭐⭐

📌 考频星级说明：基于历年 GESP 二级真题统计分析，⭐越多表示出题频率越高、分值占比越大。①~⑤是选择判断题的"概念基本盘"，⑥⑦⑧则是编程题的"逻辑铁三角"——两道编程题几乎都围绕分支、循环和数学函数展开。

三、🔍 八大考点逐一拆解

下面逐个说明每个考点 "考什么" 和 "怎么考"，每个模块配一段最小 C++ 示例，先混个脸熟。

① 计算机存储与网络

🎯 考什么

三种存储器：
- ROM（只读存储器）：出厂写入，断电后数据不丢失，常用来存放 BIOS 等启动程序
- RAM（随机存取存储器）：可读可写，就是我们说的"内存条"，断电后数据全部丢失
- CACHE（高速缓存）：介于 CPU 和内存之间，速度最快、容量最小、价格最贵，缓存 CPU 常用的数据。 CACHE也是易失性存储，断电后数据丢失；只有ROM是非易失性的。
速度从快到慢：寄存器 > CACHE > 内存(RAM) > 外存（硬盘/U盘）；容量则反过来
计算机网络分类（按覆盖范围）：局域网 LAN（如校园网、机房网）、城域网 MAN（一座城市）、广域网 WAN（跨城市跨国，Internet 是最大的广域网）
OSI 七层模型（从下到上）：物理层、数据链路层、网络层、传输层、会话层、表示层、应用层
TCP/IP 四层模型（从下到上）：网络接口层、网际层（网络层）、传输层、应用层
IP 地址：IPv4 由 32 位二进制组成，写成"点分十进制"四段，每段 0~255（如 192.168.1.100）；子网掩码用来区分网络位和主机位
存储容量单位：1 Byte = 8 bit（大写 B 是字节、小写 b 是位）；相邻单位以 1024 进位——1KB=1024B、1MB=1024KB、1GB=1024MB、1TB=1024GB（切记不是 1000）

存储容量单位换算示例：

cpp

#include <iostream>
using namespace std;

int main() {
    // 存储容量单位换算：1KB = 1024B，1MB = 1024KB，1GB = 1024MB
    cout << "1KB = " << 1LL * 1024 << "B" << endl;          // 1024
    cout << "1MB = " << 1LL * 1024 * 1024 << "B" << endl;   // 1048576
    cout << "1GB = " << 1LL * 1024 * 1024 * 1024 << "B" << endl; // 1073741824
    return 0;
}

📝 怎么考

题型	出题方式
单选题	ROM/RAM/CACHE 特性辨析、网络分类判断、OSI/TCP 层次对应、IP 地址合法性与分类
判断题	"RAM 断电后数据丢失"（对！）、"ROM 可以随意读写"（错！只读）、"TCP/IP 是七层模型"（错，四层）
编程题	不直接考概念，但 IP、子网是选择题的"压轴常客"

🔥 高频考点：OSI 七层与 TCP/IP 四层的对应关系——TCP/IP 的应用层对应 OSI 的应用层+表示层+会话层，传输层对传输层，网际层对网络层，网络接口层对数据链路层+物理层。口诀：上三对一、下二对一。

⚠️ 易错点：①RAM 断电丢失、ROM 断电不丢失，每年都有人选反；②CACHE 是高速缓存，速度比内存快、容量比内存小，别当成"外存"；③OSI 七层顺序记牢口诀"物、链、网、传、会、表、应"；④IP 地址每段范围是 0~255，出现 256 立即非法，127.0.0.1 是回环地址。

② 程序设计语言

🎯 考什么

程序设计语言的分类（按接近硬件的程度）：

分类	代表	特点
机器语言	0/1 二进制代码	计算机唯一能直接执行的语言，人最难读
汇编语言	助记符（如 MOV、ADD）	低级语言，需要汇编器翻译，与硬件强相关
高级语言	C/C++、Python、Java	接近自然语言和数学公式，易学易移植

高级语言的两种执行方式：
- 编译型：源代码一次性翻译成机器码再运行（如 C++），运行速度快
- 解释型：由解释器逐行读取、逐行执行（如 Python），灵活但相对慢
常见的高级语言：C、C++、Python、Java、C#、Pascal、Go 等

cpp

#include <iostream>
using namespace std;

int main() {
    // C++ 是编译型语言：源码先整体编译成机器码，再运行
    cout << "Hello, GESP!" << endl;
    return 0;
}

📝 怎么考

题型	出题方式
单选题	语言分类辨析、编译型与解释型的区别、判断哪种是高级语言
判断题	"计算机能直接执行高级语言"（错！直接执行的只有机器语言）、"汇编语言属于高级语言"（错，是低级语言）
编程题	不直接考，但理解"编译/解释"有助于理解报错方式

🔥 高频考点：机器语言、汇编语言、高级语言三者特点对比是概念题经典款——记住"计算机唯一直接认识的是机器语言（二进制）"，汇编和高级语言都需要翻译。

⚠️ 易错点：①汇编语言是低级语言，不是高级语言；②C++ 是编译型、Python 是解释型，别记反；③高级语言"可读性好、可移植性强"，但运行效率通常不如手写机器码/汇编。

③ 流程图

🎯 考什么

流程图的概念：用规定的图形符号 + 流程线，直观描述算法步骤的工具
常用符号必须认清：

符号	形状	含义
开始/结束框	椭圆（圆角矩形）	算法的起点和终点
处理框	矩形	赋值、计算等操作
判断框	菱形	条件判断，一个入口、两个出口（是/否）
输入/输出框	平行四边形	读入数据、输出结果
流程线	箭头	指示执行方向

绘制流程图：根据算法或代码画出流程图；描述流程图：根据流程图判断输出结果、循环次数

流程图与代码的对应（判断奇偶）：

cpp

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;                    // 平行四边形：输入框
    if (n % 2 == 0)              // 菱形：判断框（两个出口）
        cout << "偶数" << endl;  // 矩形处理 + 平行四边形输出
    else
        cout << "奇数" << endl;
    return 0;
}

📝 怎么考

题型	出题方式
单选题	读流程图判断输出结果、数循环次数、判断符号名称
判断题	"判断框有两个出口"（对！是/否各一个）、"平行四边形表示处理"（错，表示输入/输出）
编程题	不直接考，但画流程图是理清编程题思路的好方法

🔥 高频考点：读流程图算结果是二级特色题——给定一张带分支和循环的流程图，问输出什么或循环执行几次。做法：拿笔在纸上跟着箭头走一遍，每走一步记下变量的值。

⚠️ 易错点：①菱形判断框出口标"是/否"（或 Y/N），走哪条线一定要看清；②循环流程图中，变量更新语句的位置（在判断前还是判断后）直接影响循环次数；③椭圆=开始结束、矩形=处理、平行四边形=输入输出，三个形状别张冠李戴。

④ ASCII编码

🎯 考什么

ASCII 码（美国信息交换标准代码）：用 7 位二进制表示字符，共 128 个，是字符与数字之间的"桥梁"
三个必背锚点：

字符	ASCII 码	范围
`'0'`	48	数字字符 `'0'`~`'9'`：48~57
`'A'`	65	大写字母 `'A'`~`'Z'`：65~90
`'a'`	97	小写字母 `'a'`~`'z'`：97~122

规律：大小写字母相差 32（小写 = 大写 + 32）；空格 ' ' = 32
字符与码值互转：C++ 中 char 本质是 1 字节整数，可直接参与运算——用 (int)c 查码值、用 (char)n 按码值取字符

cpp

#include <iostream>
using namespace std;

int main() {
    char c = 'A';
    cout << (int)c << endl;         // 65：字符转 ASCII 码
    cout << (char)(c + 32) << endl; // a ：大写转小写（码值 +32）
    cout << (char)('0' + 5) << endl;// 5 ：'0' 的码值 48 加 5 得 '5'
    return 0;
}

📝 怎么考

题型	出题方式
单选题	给定字符求码值、给定码值求字符、大小写转换、字符表达式求值
判断题	"'A' 的 ASCII 码是 65"（对！）、"字符不能参与算术运算"（错，char 本质是整数）
编程题	大小写转换、字符统计、密码移位（凯撒密码）等题型的基础

🔥 高频考点：ASCII 码推算逢考必出。记住 '0'=48、'A'=65、'a'=97 三个锚点，任意字符都能推：如 'D' = 65+3 = 68，'f' = 97+5 = 102。

⚠️ 易错点：①字符 '0' 的码值是 48，不是数字 0，'0' 和 0 完全是两回事；②大写转小写 +32、小写转大写 -32，方向别搞反；③C++ 中 char 参与运算用的是码值，如 'A' + 1 结果是整数 66，要输出字符得强转 (char)('A' + 1)。

⑤ 数据类型转换

🎯 考什么

隐式类型转换（自动转换）：混合运算时编译器/解释器自动提升类型，如 int + double → 结果为 double；赋值时右侧自动转成左侧类型
强制类型转换（显式转换）：程序员手动指定转换——C++ 用 (类型)值 或 类型(值)；
转换规则：
- 浮点数转整数：小数部分直接截断（3.99 → 3），不是四舍五入
- C++ 中两个整数相除结果仍是整数（7 / 2 = 3），小数被截断

cpp

#include <iostream>
using namespace std;

int main() {
    double pi = 3.99;
    cout << (int)pi << endl;    // 3：强制转换，小数部分直接截断（不是 4！）
    cout << 7 / 2 << endl;      // 3：两个 int 相除，结果截断为整数
    cout << 7.0 / 2 << endl;    // 3.5：隐式转换，2 提升为 double 后相除
    return 0;
}

📝 怎么考

题型	出题方式
单选题	表达式结果求值、判断结果类型、混合运算后的类型提升
判断题	"强制转换 3.99 得到 4"（错！截断得 3）、"C++ 中 7/2 等于 3.5"（错，等于 3）
编程题	求平均分、单位换算等场景中，除法和取整无处不在

🔥 高频考点：整数除法截断是二级第一大"暗坑"——求平均分时 sum / n 两个整数相除会丢掉小数部分，想保留小数要写成 sum * 1.0 / n 或 (double)sum / n。

⚠️ 易错点：①(int)3.99 = 3，截断不是四舍五入，想四舍五入要 (int)(x + 0.5)；②char 和 int 混合运算时 char 会隐式提升为 int（实际用的是 ASCII 码值）。

⑥ 多层分支结构

🎯 考什么

if 语句：单分支，条件成立才执行
if...else 语句：双分支；if...else if...else：多分支（条件要按从严格到宽松的顺序写）
分支嵌套：if 里面再套 if/else，处理"条件里还有条件"的情况；注意 else 总是与它上面最近的、未配对的 if 配对
switch 语句（C++）：switch(表达式) 搭配 case 常量: 和 default:；表达式只能是整型或字符型
case 穿透：某个 case 末尾没有 break，执行完会继续往下执行后面的 case

成绩分级示例：

cpp

#include <iostream>
using namespace std;

int main() {
    int score;
    cin >> score;

    // 多分支：if...else if...else（条件从高到低）
    if (score >= 90)      cout << "A" << endl;
    else if (score >= 80) cout << "B" << endl;
    else if (score >= 60) cout << "C" << endl;
    else                  cout << "D" << endl;

    // switch：case 10 故意不写 break，利用"穿透"让 100 分也走"优"
    switch (score / 10) {
        case 10:
        case 9:  cout << "优" << endl; break;   // 90~100
        case 8:  cout << "良" << endl; break;   // 80~89
        case 7:
        case 6:  cout << "中" << endl; break;   // 60~79
        default: cout << "不及格" << endl;      // 其余情况
    }
    return 0;
}

📝 怎么考

题型	出题方式
单选题	读嵌套 if 判断输出、switch 执行路径（穿透几次）、else 配对问题
判断题	"每个 case 后面都必须有 break"（错！穿透有时是故意利用的）、"switch 判断条件可以是小数"（C++ 中错，只能整型/字符型）
编程题	成绩分级、闰年判断、分段计费、菜单选择——分支是编程题的"骨架"

🔥 高频考点：switch 的 case 穿透是选择题超高频陷阱——题目问某输入下输出什么，关键看每个 case 后面有没有 break。没有 break 就"一路穿透"执行到底，直到遇到 break 或 switch 结束。

⚠️ 易错点：①case 末尾忘写 break 导致穿透（除非故意合并分支）；②多分支条件顺序写错会导致后面的分支永远进不去（如把 >=60 写在 >=90 前面）；③嵌套 if 中 else 与最近的未配对 if 配对，缩进/花括号能救命；④C++ 的 switch 表达式不能是 float/double 或字符串。

⑦ 多层循环语句

🎯 考什么

while 循环：先判断条件，成立才执行循环体（可能一次都不执行）
do...while 循环：先执行一次循环体，再判断条件——循环体至少执行一次
for 循环：for(初始化; 条件; 更新)，三部分写在一行，是计数循环的首选
循环嵌套（多层循环）：外层循环走 1 步，内层循环走完整 1 圈；总次数 = 外层次数 × 内层次数
break：立即跳出当前所在的那一层循环；continue：跳过本次循环剩余语句，直接进入下一次判断

打印 3×3 星号矩形 + do-while 体验：

cpp

#include <iostream>
using namespace std;

int main() {
    // 嵌套循环：外层控制行，内层控制列
    for (int i = 1; i <= 3; i++) {        // 外层：行
        for (int j = 1; j <= 3; j++) {    // 内层：列（外层走1步，内层走3步）
            cout << "* ";
        }
        cout << endl;                      // 每行结束换行
    }

    // do-while：先执行后判断，循环体至少执行一次
    int x = 100;
    do {
        cout << x << endl;   // 条件一开始就假，这里仍会输出 1 次：100
        x++;
    } while (x < 5);        // 注意末尾有分号
    return 0;
}

📝 怎么考

题型	出题方式
单选题	循环次数计算、嵌套循环输出图形、do-while 与 while 的执行次数对比、break/continue 后的走向
判断题	"do-while 循环至少执行一次"（对！）、"break 可以一次跳出所有层循环"（错，只跳一层）
编程题	打印图形、九九乘法表、枚举统计、累加累乘——两道编程题至少一道以嵌套循环为核心

🔥 高频考点：嵌套循环打印图形是二级编程题的标志题型（矩形、三角形、九九乘法表）。套路固定：外层循环控制行，内层循环控制列，每行打完输出换行；内层循环的次数往往与外层变量 i 有关。

⚠️ 易错点：①do-while 至少执行一次，while 可能一次都不执行——两者对比题年年出现；②do-while 的 while(条件); 末尾有分号，忘写编译报错；③内层循环变量要靠 for 自动重置，用 while 写嵌套时重置语句放错位置是头号 bug；④循环边界 <= 还是 < 差一次，打印图形时数清楚行数和列数。

⑧ 数学函数

🎯 考什么

二级常用的数学函数（需 #include <cmath>，随机数需 <cstdlib> 和 <ctime>，max/min 需 <algorithm>）：

功能	C++ 写法	头文件
绝对值	`abs(x)`（整数）/ `fabs(x)`（浮点）	`<cstdlib>` / `<cmath>`
平方根	`sqrt(x)`	`<cmath>`
最大值	`max(a, b)`、`max({a,b,c})`	`<algorithm>`
最小值	`min(a, b)`、`min({a,b,c})`	`<algorithm>`
随机数	`rand()`、`srand(种子)`	`<cstdlib>`

rand()：返回 0 ~ RAND_MAX 之间的非负整数；rand() % n（n 为正）得到 0 ~ n-1 的随机数。（C++ 中取模结果的符号与被除数相同；因为 rand() 恒为非负，所以 rand() % n 的结果也恒为非负）
srand()：设置随机数种子，通常用 srand(time(0)) 以当前时间播种；不播种则每次运行得到相同序列

cpp

#include <iostream>
#include <cmath>       // sqrt、fabs 等数学函数
#include <cstdlib>     // rand、srand
#include <ctime>       // time
#include <algorithm>   // max、min
using namespace std;

int main() {
    cout << abs(-5) << endl;        // 5：绝对值
    cout << sqrt(16) << endl;       // 4：平方根（结果是 double 类型 4.0）
    cout << max(3, 7) << endl;      // 7：最大值
    cout << min(3, 7) << endl;      // 3：最小值

    srand(time(0));                 // 用当前时间播种：不播种每次运行结果都一样！
    cout << rand() % 100 << endl;   // 0~99 的随机整数（共 100 种可能）
    return 0;
}

📝 怎么考

题型	出题方式
单选题	函数返回值类型、`rand()%n` 的范围、缺少头文件/播种的后果
判断题	"不调用 srand 也能每次得到不同随机数"（错！默认种子固定，序列相同）、"sqrt(16) 的结果是整数 4"（结果是 4.0，浮点型）
编程题	随机数模拟（掷骰子、随机抽奖）、求最值、距离/平方根计算

🔥 高频考点：rand() 与 srand() 的搭配几乎逢考必出——srand(time(0)) 播种一次，rand() % n 生成 0~n-1；想要 1~n 就写 rand() % n + 1。

⚠️ 易错点：①rand() 必须先 srand() 播种，且整个程序播种一次即可，放进循环里反复播种反而不随机；②rand() % 100 的范围是 0~99，不是 1~100；③sqrt() 返回的是 double，参与整数运算时注意类型转换；④C++ 使用数学函数前确认已 #include <cmath>（max/min 在 <algorithm>）。

四、📈 备考建议：如何高效攻克二级？

1️⃣ 概念题：先理解、再记忆、多对比

二级的选择判断题有一半是计算机常识（存储、网络、语言、流程图、ASCII）。这类题不用写代码，但最容易混淆：

存储三兄弟 ROM/RAM/CACHE，列一张对比表（能否写入、断电是否丢失、速度、用途）
OSI 七层 vs TCP/IP 四层，画一张层次对应图，口诀背熟
ASCII 三个锚点 48/65/97 抄在草稿纸显眼处，做题随时推算

2️⃣ 语法题：光看懂不够，必须亲手敲

类型转换、多层分支、多层循环、数学函数，看十遍不如敲一遍。每学一个语法点，自己写 3 个小程序验证：

故意把 7/2 和 7.0/2 都跑一遍，亲眼看到 3 和 3.5
故意删掉 switch 里的 break，观察 case 穿透现象
把 while 改成 do-while，验证"至少执行一次"

3️⃣ 编程题：嵌套循环是主战场

两道编程题（50分）的核心套路是：分支 + 循环 + 数学函数的组合。备考时重点练三类题：

打印图形（矩形、三角形、九九乘法表）——练嵌套循环
分级分类（成绩等级、闰年、分段计费）——练多层分支
枚举统计（找最值、计数、随机模拟）——循环 + 函数综合

4️⃣ 真题是最好的复习资料

建议按以下顺序刷题：

按模块分类刷 → 找到薄弱点（多数同学卡在子网划分和嵌套循环）
按套卷限时练 → 训练 120 分钟的时间分配
复盘错题 → 把易错点（截断、穿透、断电丢失……）整理成自己的"避坑清单"

五、📝 实战练习

学完全部 9 章后，用下面这组题检验自己的掌握程度。每题都对应一个核心考点，做错了就回到对应章节复习。

练习题 1（单选题）

题目： 下列存储器中，访问速度最快的是（）

A. 内存 RAM　　B. 硬盘　　C. CACHE　　D. ROM

🔑 点击查看答案与解析

答案： C

解析： 速度从快到慢：寄存器 > CACHE > 内存(RAM) > 外存(硬盘/U盘)。CACHE 是高速缓冲存储器，位于 CPU 与内存之间，速度最快、容量最小、价格最贵。选 C。（对应章节：第2章存储与网络）

练习题 2（判断题）

题目： "汇编语言使用助记符，可读性好，属于高级语言。" 这句话对吗？为什么？

🔑 点击查看答案与解析

答案： ×（错误）

解析： 汇编语言虽然使用助记符（MOV、ADD 等）比机器语言好记，但它仍然是低级语言——面向机器、与硬件强相关、每条指令基本对应一条机器指令。高级语言是 C/C++、Python、Java 等接近自然语言、屏蔽硬件细节的语言。（对应章节：第3章程序设计语言）

练习题 3（判断题）

题目： 流程图中，菱形符号表示（）

A. 开始/结束　　B. 处理/计算　　C. 条件判断　　D. 输入/输出

🔑 点击查看答案与解析

答案： C

解析： 菱形 = 判断框（一个入口、两个出口：是/否）；圆角矩形 = 起止框；矩形 = 处理框；平行四边形 = 输入/输出框。选 C。（对应章节：第4章流程图）

练习题 4（单选题）

题目： 已知 'A' 的 ASCII 码为 65，则表达式 'F' - 'A' + '0' 的值是（）

A. 5　　B. 53　　C. 70　　D. '5'

🔑 点击查看答案与解析

答案： B

解析： 'F'-'A' = 5（F 是第 6 个字母，偏移量为 5），再加 '0'（48）= 5 + 48 = 53。注意：这是 int 类型的 53，对应的字符是 '5'，但表达式的值是整数 53。选 B。（对应章节：第5章 ASCII编码）

练习题 5（程序阅读题）

题目： 写出下面程序的输出：

cpp

cout << 7 / 2 << " " << 7.0 / 2 << endl;
cout << (int)3.99 << " " << (double)(5/2) << endl;

🔑 点击查看答案与解析

答案：

3 3.5
3 2

解析：

7/2 两个 int 相除 = 3（整数除法，截断小数）；
7.0/2 有 double 参与 = 3.5（浮点除法）；
(int)3.99 截断小数 = 3（不是 4！）；
(double)(5/2) 先算括号内 5/2=2（已截断），再转 double = 2。

（对应章节：第6章数据类型转换）

练习题 6（单选题）

题目： 执行以下代码后，输出是（）

cpp

int x = 2;
switch(x) {
    case 1: cout << "A";
    case 2: cout << "B";
    case 3: cout << "C"; break;
    default: cout << "D";
}

A. B　　B. BC　　C. BCD　　D. ABC

🔑 点击查看答案与解析

答案： B

解析： x=2 匹配 case 2，输出 B；没有 break，发生 case 穿透，继续执行 case 3 输出 C；遇到 break 跳出 switch。最终输出 BC。选 B。（对应章节：第7章多层分支结构）

练习题 7（单选题）

题目： 下面的双重循环中，cout << "*"; 语句共执行多少次？（）

cpp

for(int i=1; i<=3; i++)
    for(int j=1; j<=i; j++)
        cout << "*";

A. 3　　B. 6　　C. 9　　D. 12

🔑 点击查看答案与解析

答案： B

解析： 内层循环次数依赖外层变量 i，需要逐圈累加：

i=1 时，j 从 1 到 1 → 1 次
i=2 时，j 从 1 到 2 → 2 次
i=3 时，j 从 1 到 3 → 3 次

总计 = 1 + 2 + 3 = 6 次。选 B。（对应章节：第8章多层循环语句）

练习题 8（单选题）

题目： 要生成一个 [20, 60] 范围内的随机整数，正确的写法是（）

A. rand() % 40 + 20　　　B. rand() % 41 + 20 C. rand() % 60　　　　　D. rand() % 41 + 19

🔑 点击查看答案与解析

答案： B

解析： 万能公式 rand() % (b-a+1) + a。区间 [20, 60] 的个数 = 60−20+1 = 41，起点 = 20，所以是 rand() % 41 + 20。选 B。（对应章节：第9章数学函数）

练习题 9（判断题）

题目： 判断下列说法是否正确（快速自检，全部答对才算过关）：

① RAM 断电后数据不丢失，ROM 断电后数据丢失。（　） ② Internet 是世界上最大的广域网（WAN）。（　） ③ C++ 是解释型语言，Python 是编译型语言。（　） ④ 判断框（菱形）有一个入口和两个出口。（　） ⑤ '0' 的 ASCII 码值为 0。（　） ⑥ int a = 3.99; 变量 a 的值为 4（四舍五入）。（　） ⑦ break 语句可以一次跳出多层循环。（　） ⑧ srand(time(0)) 应该放在循环内部，每次生成随机数前都调用一次。（　）

🔑 点击查看答案与解析

答案： ① ×　② ✓　③ ×　④ ✓　⑤ ×　⑥ ×　⑦ ×　⑧ ×

解析：

① ×：说反了——RAM 断电丢失，ROM 断电不丢；
② ✓：Internet 是世界上最大的广域网；
③ ×：说反了——C++ 是编译型，Python 是解释型；
④ ✓：判断框一进两出（是/否两个出口）；
⑤ ×：'0' 的 ASCII 码是 48，不是 0；
⑥ ×：double→int 是截断，不是四舍五入，3.99 → 3；
⑦ ×：break 只跳出本层循环，不是多层；
⑧ ×：srand 整个程序只调用一次，放在循环外（main 开头）。

🎯 自评：答对 6 题以上 = 基础扎实；答对 8 题 = 二级稳了！

练习题 10（编程题）

题目： 输入 n 个学生的成绩（整数，0~100），统计：

平均分（保留 1 位小数）
最高分和最低分
优秀人数（90 分及以上）和不及格人数（60 分以下）

输入样例：

5
85 92 78 56 100

输出样例：

平均分:82.2
最高:100 最低:56
优秀:2人 不及格:1人

🔑 点击查看答案与解析

参考代码（C++）：

cpp

#include <iostream>
#include <iomanip>
#include <algorithm>   // max、min
using namespace std;

int main() {
    int n;
    cin >> n;

    int sum = 0;
    int mx = 0, mn = 100;     // 最高分、最低分
    int excellent = 0, fail = 0; // 优秀、不及格人数

    for (int i = 1; i <= n; i++) {
        int score;
        cin >> score;
        sum += score;                     // 累加求和
        mx = max(mx, score);              // 更新最高分
        mn = min(mn, score);              // 更新最低分
        if (score >= 90) excellent++;     // 优秀计数
        if (score < 60) fail++;           // 不及格计数
    }

    double avg = (double)sum / n;         // 求平均分（转double避免整数除法）

    cout << fixed << setprecision(1);
    cout << "平均分:" << avg << endl;
    cout << "最高:" << mx << " 最低:" << mn << endl;
    cout << "优秀:" << excellent << "人 不及格:" << fail << "人" << endl;

    return 0;
}
// 输入：5  85 92 78 56 100
// sum=85+92+78+56+100=411, avg=411/5=82.2
// mx=100, mn=56, 优秀2人(92,100), 不及格1人(56) ✅

解析要点：

这是二级编程题的"集大成者"——循环 + 分支 + 数学函数 + 类型转换 + 格式化输出全部考察到了；
求平均分注意转 double（用 (double)sum / n 或 1.0 * sum / n）；
最大值初始化用一个很小的数（或第一个数），最小值用一个很大的数（或第一个数）；
优秀和不及格用两个计数器分别统计。

💡 二级备考建议：这类"输入 n 个数，求各种统计量"的题是编程题高频原型，一定要练到肌肉记忆。

⭐ 必背速记卡

┌─────────────────────────────────────────────────────┐
│  🏆 存储三兄弟                                       │
│  RAM：可读可写、断电丢失 = 内存                      │
│  ROM：只读、断电不丢 = BIOS                         │
│  CACHE：最快最小最贵、CPU和内存之间                   │
│  速度：寄存器 > CACHE > 内存 > 外存                  │
├─────────────────────────────────────────────────────┤
│  🌐 网络三件套                                       │
│  LAN局域网 < MAN城域网 < WAN广域网                   │
│  Internet是最大的广域网                              │
│  OSI七层（下→上）：物链网传会表应                     │
│  TCP/IP四层：网接口→网际→传输→应用                   │
│  上三合应用，下二合接口，传输网络各对应               │
│  IPv4：32位点分十进制4段，每段0~255                   │
│  私网三段：192.168.x.x、10.x.x.x、172.16~31.x.x      │
├─────────────────────────────────────────────────────┤
│  💻 语言与编译                                       │
│  唯一直接执行：机器语言（二进制）                     │
│  汇编是低级语言，需汇编器翻译                         │
│  C++编译型（整体翻译、生成exe、运行快）               │
│  Python解释型（逐行执行、跨平台好）                   │
│  C++流程：源.cpp → 编译 → .obj → 链接 → .exe        │
├─────────────────────────────────────────────────────┤
│  📊 流程图六符号                                     │
│  圆角矩形=起止，矩形=处理，菱形=判断                 │
│  平行四边形=输入输出，箭头=流程线，圆圈=连接点         │
│  当型先判断后执行（0次），直到型先执行后判断（1次）   │
├─────────────────────────────────────────────────────┤
│  🔤 ASCII三锚点                                     │
│  '0'=48, 'A'=65, 'a'=97                             │
│  大小写差32，小写更大                                │
│  数字字符转数值：ch - '0'                            │
│  char运算升为int，想输出字符要强转                   │
├─────────────────────────────────────────────────────┤
│  🔄 类型转换                                         │
│  混合运算向高看齐：char→int→double                   │
│  整数除法会截断，想得到小数先转double                 │
│  (double)5/2=2.5，(double)(5/2)=2，括号很重要        │
│  bool非0即真，true=1, false=0                        │
├─────────────────────────────────────────────────────┤
│  🔀 分支与循环                                       │
│  else配最近未配对if，与缩进无关                       │
│  switch只能整型/字符型，case必须是常量                │
│  无break就穿透，一路执行到结束                        │
│  短路求值：&&左假右不执行，||左真右不执行             │
│  外层走一步，内层走一圈                               │
│  break跳本层，continue跳本次                         │
│  三大套路：sum求和、cnt计数、mx最值                  │
├─────────────────────────────────────────────────────┤
│  🎲 数学函数                                         │
│  整数abs浮点fabs，sqrt返回double                     │
│  max/min在algorithm，三数用初始化列表                │
│  rand返回伪随机，不播种每次都一样                     │
│  srand(time(0))只调一次，放在循环外                   │
│  [a,b]随机数：rand()%(b-a+1) + a                     │
└─────────────────────────────────────────────────────┘

第1章 GESP 二级考点总览 ​

🎯 本章学习目标 ​

🗺️ 本章知识图谱 ​

一、写在前面 ​

二、📊 八大考点全景总表 ​

三、🔍 八大考点逐一拆解 ​

① 计算机存储与网络 ​

② 程序设计语言 ​

③ 流程图 ​

④ ASCII编码 ​

⑤ 数据类型转换 ​

⑥ 多层分支结构 ​

⑦ 多层循环语句 ​

⑧ 数学函数 ​

四、📈 备考建议：如何高效攻克二级？ ​

1️⃣ 概念题：先理解、再记忆、多对比 ​

2️⃣ 语法题：光看懂不够，必须亲手敲 ​

3️⃣ 编程题：嵌套循环是主战场 ​

4️⃣ 真题是最好的复习资料 ​

五、📝 实战练习 ​

练习题 1（单选题） ​

练习题 2（判断题） ​

练习题 3（判断题） ​

练习题 4（单选题） ​

练习题 5（程序阅读题） ​

练习题 6（单选题） ​

练习题 7（单选题） ​

练习题 8（单选题） ​

练习题 9（判断题） ​

练习题 10（编程题） ​

⭐ 必背速记卡 ​

第1章 GESP 二级考点总览

🎯 本章学习目标

🗺️ 本章知识图谱

一、写在前面

二、📊 八大考点全景总表

三、🔍 八大考点逐一拆解

① 计算机存储与网络

② 程序设计语言

③ 流程图

④ ASCII编码

⑤ 数据类型转换

⑥ 多层分支结构

⑦ 多层循环语句

⑧ 数学函数

四、📈 备考建议：如何高效攻克二级？

1️⃣ 概念题：先理解、再记忆、多对比

2️⃣ 语法题：光看懂不够，必须亲手敲

3️⃣ 编程题：嵌套循环是主战场

4️⃣ 真题是最好的复习资料

五、📝 实战练习

练习题 1（单选题）

练习题 2（判断题）

练习题 3（判断题）

练习题 4（单选题）

练习题 5（程序阅读题）

练习题 6（单选题）

练习题 7（单选题）

练习题 8（单选题）

练习题 9（判断题）

练习题 10（编程题）

⭐ 必背速记卡