GESP C++ 二级复习资料:常用代码模板、核心考点

第一部分:GESP C++ 二级常用代码与讲解

1. 标准程序结构

#include <bits/stdc++.h>
using namespace std;

int main() {
    // 1. 定义变量
    int a, b;

    // 2. 输入
    cin >> a >> b;

    // 3. 计算
    int sum = a + b;

    // 4. 输出
    cout << sum << '\n';

    return 0;
}

讲解:

  • #include <bits/stdc++.h>:常见竞赛环境中的万能头文件;若考试环境不支持,可按需包含 <iostream>、<cmath>、<algorithm>、<cstdlib>、<ctime>。
  • using namespace std;:之后可以直接写 cin、cout。
  • int main():程序入口。
  • cin >>:输入;cout <<:输出。
  • return 0;:程序正常结束。

2. 输入输出与格式控制

int a, b;
cin >> a >> b;
cout << a << ' ' << b << '\n';

输出小数:

#include <bits/stdc++.h>
using namespace std;

int main() {
    double x = 3.1415926;
    cout << fixed << setprecision(2) << x << '\n';
    return 0;
}

输出 3.14。

注意:fixed << setprecision(2) 表示小数点后保留两位,不是总共两位。

3. 数据类型与常见运算

类型常见用途取值范围(大致)示例
int一般整数约 −2.1×10⁹ ~ 2.1×10⁹(约 ±21 亿)int n=10;
long long较大的整数约 −9.2×10¹⁸ ~ 9.2×10¹⁸long long sum=0;
float单精度小数约 ±3.4×10³⁸,约 6~7 位有效数字float x=1.5f;
double双精度小数约 ±1.7×10³⁰⁸,约 15~16 位有效数字double y=3.14;
char单个字符对应 0~255(ASCII 常用 0~127)char c='A';
bool真/假(只有两个值)false 或 truebool ok=true;

补充:int 上限约 2147483647,long long 上限约 9223372036854775807。累加、累乘结果可能超过 int 时,应改用 long long。浮点数(float/double)表示的是近似值,不能精确表示所有小数。float x=1.5f; 里的 f 后缀表示这是一个 float 字面量(默认小数是 double),二级通常写 double 即可,不必纠结 f 后缀。

常见运算符:

运算符含义例子
+加法a + b
-减法a - b
*乘法a * b
/除法(两个整数相除,结果只保留整数部分)7 / 2 得 3
%取余(求余数)17 % 10 得 7
>大于a > b
<小于a < b
>=大于等于a >= b
<=小于等于a <= b
==等于(判断相等)a == b
!=不等于a != b
&&逻辑与(并且)a > 0 && b > 0
\|\|逻辑或(或者)a == 0 \|\| b == 0
!逻辑非(取反)!ok
++自增(加 1)i++
--自减(减 1)i--
+=累加(自己加一个数)sum += i
-=累减(自己减一个数)sum -= i

整数除法特别重要:

cout << 7 / 2 << '\n';          // 3
cout << 7.0 / 2 << '\n';        // 3.5
cout << (double)7 / 2 << '\n';  // 3.5

只要参与整数除法的两个操作数都是整数,结果就会丢弃小数部分。

4. 条件判断

4.1 单分支 if

if (x > 0) {
    cout << "Positive";
}

条件成立才执行大括号里的语句。

4.2 if...else

if (x % 2 == 0) {
    cout << "Even";
} else {
    cout << "Odd";
}

4.3 多层 if...else if

if (score >= 90) {
    cout << "A";
} else if (score >= 80) {
    cout << "B";
} else if (score >= 60) {
    cout << "C";
} else {
    cout << "D";
}

条件从上向下判断,满足一个分支后,其余分支不再执行。区间条件要注意先后顺序。

4.4 多条件判断

if (age >= 10 && age <= 12) {
    cout << "符合";
}

if (x == 0 || y == 0) {
    cout << "至少一个为0";
}

三个逻辑运算符:

运算符名称含义
&&逻辑与左右两个条件都为真时,整体才为真
\|\|逻辑或左右两个条件至少一个为真时,整体就为真
!逻辑非把真变成假、把假变成真

4.5 switch

int day;
cin >> day;

switch (day) {
    case 1:
        cout << "Monday";
        break;
    case 2:
        cout << "Tuesday";
        break;
    case 3:
        cout << "Wednesday";
        break;
    default:
        cout << "Other";
}

break 用于跳出 switch。忘记写 break,可能继续执行后面的 case,这叫贯穿执行。

5. 三种循环

5.1 for 循环

for (int i = 1; i <= 5; i++) {
    cout << i << ' ';
}

输出:1 2 3 4 5

结构:

for (初始值; 循环条件; 每轮变化) {
    循环体;
}

适合已知循环次数或范围的场景。

5.2 while 循环

int i = 1;
while (i <= 5) {
    cout << i << ' ';
    i++;
}

先判断条件,条件成立才执行循环体。循环变量忘记变化,可能造成死循环。

5.3 do...while 循环

int x;
do {
    cin >> x;
} while (x < 0);

先执行一次循环体,再判断条件,所以至少执行一次。注意结尾有分号。

5.4 break 与 continue

for (int i = 1; i <= 10; i++) {
    if (i == 5) {
        break;
    }
    cout << i << ' ';
}

输出 1 2 3 4。break 直接结束当前循环。

for (int i = 1; i <= 5; i++) {
    if (i == 3) {
        continue;
    }
    cout << i << ' ';
}

输出 1 2 4 5。continue 跳过本轮后续语句,进入下一轮循环。

6. 循环累加、累乘与计数

6.1 累加 1 到 n

int n;
cin >> n;

int sum = 0;
for (int i = 1; i <= n; i++) {
    sum += i;
}
cout << sum;

累加变量初值一般设为 0。

6.2 累乘 1 到 n(阶乘)

int n;
cin >> n;

long long ans = 1;
for (int i = 1; i <= n; i++) {
    ans *= i;
}
cout << ans;

累乘变量初值一般设为 1。若 n 较大,注意整数范围。

6.3 条件计数

int n;
cin >> n;

int cnt = 0;
for (int i = 1; i <= n; i++) {
    if (i % 3 == 0) {
        cnt++;
    }
}
cout << cnt;

cnt++ 表示符合条件的数量加一。

7. 双重循环与枚举

for (int i = 1; i <= 3; i++) {
    for (int j = 1; j <= 4; j++) {
        cout << i << "," << j << "  ";
    }
    cout << '\n';
}

外层循环每执行一次,内层循环会完整执行一遍。外层 3 次、内层每次 4 次,总共执行 12 次。

百鸡问题的枚举思想

假设三种鸡的数量分别为 x、y、z。根据题目限制枚举其中两个变量,第三个变量可以由总数关系推出,再检查价格关系。

for (int x = 0; x <= 100; x++) {
    for (int y = 0; y <= 100 - x; y++) {
        int z = 100 - x - y;
        // 在这里判断价格条件
    }
}

重点:尽量缩小枚举范围,避免不必要的循环。

8. 数位拆分:二级高频模板

8.1 逐位取出数字

int n;
cin >> n;

while (n > 0) {
    int digit = n % 10; // 取个位
    cout << digit << '\n';
    n /= 10;            // 去掉个位
}

例如输入 583,依次取出 3、8、5。

8.2 求数位和

int n;
cin >> n;

int sum = 0;
while (n > 0) {
    sum += n % 10;
    n /= 10;
}
cout << sum;

8.3 统计位数

int n;
cin >> n;

int cnt = 0;
if (n == 0) {
    cnt = 1;
} else {
    while (n > 0) {
        cnt++;
        n /= 10;
    }
}
cout << cnt;

8.4 数字逆序

int n;
cin >> n;

int rev = 0;
while (n > 0) {
    rev = rev * 10 + n % 10;
    n /= 10;
}
cout << rev;

例如 1234 变为 4321。注意:如果原数字末尾有 0,逆序后前导 0 不会保留,这是整数本身的表示特点。

8.5 回文数判断

int n;
cin >> n;

int old = n;
int rev = 0;

while (n > 0) {
    rev = rev * 10 + n % 10;
    n /= 10;
}

if (old == rev) {
    cout << "Yes";
} else {
    cout << "No";
}

一定要先保存原数,因为循环会把 n 除到 0。

9. 素数判断与区间计数

9.1 判断一个数是否为素数

bool isPrime(int n) {
    if (n < 2) {
        return false;
    }

    for (int i = 2; i * i <= n; i++) {
        if (n % i == 0) {
            return false;
        }
    }
    return true;
}

解释:

  • 小于 2 的数不是素数。
  • 如果 n 能被某个 i 整除,就不是素数。
  • 只需要检查到平方根附近,因为若 n=a*b,两个因数不可能都大于 sqrt(n)。
  • i*i<=n 是常见写法;当数值特别大时要注意乘法溢出。

9.2 统计区间素数个数

int l, r;
cin >> l >> r;

int cnt = 0;
for (int n = l; n <= r; n++) {
    bool ok = true;

    if (n < 2) {
        ok = false;
    } else {
        for (int i = 2; i * i <= n; i++) {
            if (n % i == 0) {
                ok = false;
                break;
            }
        }
    }

    if (ok) {
        cnt++;
    }
}
cout << cnt;

10. 常用数学函数

#include <bits/stdc++.h>
using namespace std;

int main() {
    cout << abs(-8) << '\n';       // 8,绝对值
    cout << sqrt(25.0) << '\n';    // 5.0,平方根(结果是 double 类型)
    cout << max(3, 7) << '\n';     // 7,较大值
    cout << min(3, 7) << '\n';     // 3,较小值
    return 0;
}

注意:

  • sqrt 的结果通常是浮点类型。
  • 比较平方根结果时,按题目精度要求处理。
  • max、min 通常要求参与比较的参数类型一致。
  • abs 对整数求绝对值;浮点数可使用 fabs 或合适的重载。

随机数函数

#include <bits/stdc++.h>
using namespace std;

int main() {
    srand((unsigned)time(nullptr));
    int x = rand() % 10 + 1; // 生成 1~10
    cout << x;
    return 0;
}
  • rand() 产生伪随机整数。
  • rand()%10+1 得到 1~10 的数。
  • srand(time(nullptr)) 用当前时间设置种子。
  • 正式算法题通常不需要随机数;只有题目明确要求随机时才使用。随机数不适合用来代替确定性算法。

11. 字符与 ASCII 编码

常用 ASCII 数值:

字符十进制 ASCII
空格32
'0'48
'1'49
'9'57
'A'65
'Z'90
'a'97
'z'122
char c = 'A';
cout << int(c) << '\n';  // 65

int x = 66;
cout << char(x) << '\n'; // B

字符数字与整数数字不是一回事:

char c = '7';
int a = c - '0';  // a 为整数 7

'7' 是字符,数值编码为 55;7 是整数 7。

字符范围判断:

if (c >= '0' && c <= '9') {
    cout << "数字字符";
}

字符转换:

char lower = 'a';
char upper = lower - 'a' + 'A'; // A

12. 图形打印专题:先找行列规律,再写循环

图形题统一使用两个变量:

  • i 表示第几行。
  • j 表示当前行中的第几列。
  • 外层循环控制行,内层循环控制列。
  • 每行输出完成后,使用 cout << '\n'; 换行。

12.1 实心正方形

目标:

*****
*****
*****
*****
*****

代码:

int n = 5;
for (int i = 1; i <= n; i++) {
    for (int j = 1; j <= n; j++) {
        cout << '*';
    }
    cout << '\n';
}

规律:每一行都输出 n 个星号。

12.2 空心正方形

目标:

*****
*   *
*   *
*   *
*****

代码:

int n = 5;
for (int i = 1; i <= n; i++) {
    for (int j = 1; j <= n; j++) {
        if (i == 1 || i == n || j == 1 || j == n) {
            cout << '*';
        } else {
            cout << ' ';
        }
    }
    cout << '\n';
}

规律:第一行、最后一行、第一列、最后一列是边框。

12.3 左下直角三角形

目标:

*
**
***
****
*****

代码:

int n = 5;
for (int i = 1; i <= n; i++) {
    for (int j = 1; j <= i; j++) {
        cout << '*';
    }
    cout << '\n';
}

规律:第 i 行输出 i 个星号。

12.4 左上直角三角形

目标:

*****
****
***
**
*

代码:

int n = 5;
for (int i = 1; i <= n; i++) {
    for (int j = i; j <= n; j++) {
        cout << '*';
    }
    cout << '\n';
}

规律:第 i 行输出 n-i+1 个星号。

12.5 右下直角三角形

目标:

    *
   **
  ***
 ****
*****

代码:

int n = 5;
for (int i = 1; i <= n; i++) {
    for (int j = 1; j <= n - i; j++) {
        cout << ' ';
    }
    for (int j = 1; j <= i; j++) {
        cout << '*';
    }
    cout << '\n';
}

规律:每行先输出 n-i 个空格,再输出 i 个星号。

12.6 居中金字塔

目标:

    *
   ***
  *****
 *******
*********

代码:

int n = 5;
for (int i = 1; i <= n; i++) {
    for (int j = 1; j <= n - i; j++) {
        cout << ' ';
    }
    for (int j = 1; j <= 2 * i - 1; j++) {
        cout << '*';
    }
    cout << '\n';
}

规律:

  • 空格数:n-i
  • 星号数:2*i-1

12.7 倒金字塔

目标:

*********
 *******
  *****
   ***
    *

代码:

int n = 5;
for (int i = 1; i <= n; i++) {
    for (int j = 1; j < i; j++) {
        cout << ' ';
    }
    for (int j = 1; j <= 2 * (n - i) + 1; j++) {
        cout << '*';
    }
    cout << '\n';
}

规律:第 i 行前面 i-1 个空格,后面 2*(n-i)+1 个星号。

12.8 菱形(实心)

目标:

  *
 ***
*****
 ***
  *

代码:

int n = 3; // 上半部分高度
for (int i = 1; i <= n; i++) {
    for (int j = 1; j <= n - i; j++) cout << ' ';
    for (int j = 1; j <= 2 * i - 1; j++) cout << '*';
    cout << '\n';
}

for (int i = n - 1; i >= 1; i--) {
    for (int j = 1; j <= n - i; j++) cout << ' ';
    for (int j = 1; j <= 2 * i - 1; j++) cout << '*';
    cout << '\n';
}

规律:先打印从上到中的金字塔,再打印中线以下的倒金字塔。第二部分从 n-1 开始,避免中间行重复。

12.9 空心菱形

目标:

  *
 * *
*   *
 * *
  *

一种方法:枚举行列坐标,判断当前位置是否在菱形边界上。

int n = 5;
int mid = (n + 1) / 2;

for (int i = 1; i <= n; i++) {
    for (int j = 1; j <= n; j++) {
        if (abs(i - mid) + abs(j - mid) == mid - 1) {
            cout << '*';
        } else {
            cout << ' ';
        }
    }
    cout << '\n';
}

这里使用曼哈顿距离:abs(i-mid)+abs(j-mid)。当距离等于 mid-1 时,位置正好落在菱形边界。

12.10 X 字形

目标:

*   *
 * *
  *
 * *
*   *

代码:

int n = 5;
for (int i = 1; i <= n; i++) {
    for (int j = 1; j <= n; j++) {
        if (i == j || i + j == n + 1) {
            cout << '*';
        } else {
            cout << ' ';
        }
    }
    cout << '\n';
}

规律:

  • 主对角线:i==j
  • 副对角线:i+j==n+1

12.11 H 字形

目标:

*   *
*   *
*****
*   *
*   *

代码:

int n = 5;
int mid = (n + 1) / 2;

for (int i = 1; i <= n; i++) {
    for (int j = 1; j <= n; j++) {
        if (j == 1 || j == n || i == mid) {
            cout << '*';
        } else {
            cout << ' ';
        }
    }
    cout << '\n';
}

规律:第一列、最后一列,以及中间一行打印字符。

12.12 N 字形

目标:

*   *
**  *
* * *
*  **
*   *

代码:

int n = 5;
for (int i = 1; i <= n; i++) {
    for (int j = 1; j <= n; j++) {
        if (j == 1 || j == n || i == j) {
            cout << '*';
        } else {
            cout << ' ';
        }
    }
    cout << '\n';
}

规律:第一列、最后一列、主对角线输出字符。

12.13 棋盘/交错图案

目标:

*.*.*
.*.*.
*.*.*
.*.*.
*.*.*

代码:

int n = 5;
for (int i = 1; i <= n; i++) {
    for (int j = 1; j <= n; j++) {
        if ((i + j) % 2 == 0) cout << '*';
        else cout << '.';
    }
    cout << '\n';
}

规律:行号与列号之和的奇偶性决定字符。

12.14 数字递增三角形

目标:

1
12
123
1234
12345

代码:

int n = 5;
for (int i = 1; i <= n; i++) {
    for (int j = 1; j <= i; j++) {
        cout << j;
    }
    cout << '\n';
}

12.15 字母正方形

目标(n=4):

ABCD
BCDE
CDEF
DEFG

代码:

int n = 4;
for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
        char c = 'A' + (i + j) % 26;
        cout << c;
    }
    cout << '\n';
}

规律:第 i 行第 j 列的字母是 'A' + (i + j)。%26 的作用是:当 (i+j) 超过 25(即越过字母 Z)时回到 A 继续循环,防止越界。

12.16 图形题通用分析方法

拿到图形题,按以下顺序思考:

  1. 一共有几行?确定外层循环。
  2. 每行有几列?确定内层循环。
  3. 每个位置输出什么?用行号 i、列号 j 表示。
  4. 哪些位置输出特殊字符?写成 if 条件。
  5. 每行末尾是否需要换行?
  6. 用最小样例(如 n=3 或 n=5)手工检查。

常见坐标条件速查:

图形位置判断条件
第一行i==1
最后一行i==n
第一列j==1
最后一列j==n
主对角线i==j
副对角线i+j==n+1
中间行(奇数 n)i==(n+1)/2
中间列(奇数 n)j==(n+1)/2
棋盘交错(i+j)%2==0
空心菱形边abs(i-mid)+abs(j-mid)==mid-1

第二部分:GESP C++ 二级完整理论知识与程序阅读

1. 计算机存储基础

1.1 存储器是什么

存储器用于保存计算机运行时需要的数据和程序。按用途、速度和断电后是否保留数据,可以分为不同类型。

1.2 RAM:随机存取存储器

  • RAM 通常指内存。
  • CPU 可以较快地读取和写入 RAM。
  • RAM 用于临时保存正在运行的程序和数据。
  • 常见内存属于易失性存储器:断电后数据通常丢失。
  • RAM 容量越大,通常越有利于同时运行更多程序,但性能还受 CPU、存储设备等影响。

记忆:RAM = 内存 = 运行时临时存储 = 断电通常丢失。

1.3 ROM:只读存储器

  • ROM 的传统含义是只读存储器。
  • 通常用于保存相对固定的程序或数据。
  • 传统 ROM 断电后仍能保留内容,属于非易失性存储。
  • 现代设备中的固件可能保存在可擦写的 Flash 等非易失性存储器中,不要把所有 ROM 都理解成绝对无法改写。

记忆:ROM = 非易失性 = 断电仍可保留。

1.4 Cache:高速缓冲存储器

  • Cache 位于 CPU 与较慢存储层次之间,或集成在 CPU 内部。
  • 用于保存近期或经常访问的数据、指令。
  • 速度快、容量通常小于内存。
  • 目的是减少 CPU 等待数据的时间。
  • Cache 通常是易失性存储器。

记忆:Cache = 高速缓存 = 缩短 CPU 取数据的等待时间。

1.5 常见存储设备比较

类型主要特点断电后数据
寄存器CPU 内部,速度极快,容量很小不保留
Cache高速缓存,速度快不保留
RAM内存,程序运行时使用通常不保留
ROM/固件存储保存固定或较少变化的内容保留
HDD机械硬盘磁性介质,容量大保留
SSD固态硬盘闪存介质,无机械转动部件保留
U盘/存储卡闪存存储保留
光盘光学介质保留

考试题常见问法:哪一种断电后数据会丢失?哪一种速度更快?Cache 的作用是什么?

1.6 存储单位

  • bit(比特):最小的信息单位,取 0 或 1。
  • Byte(字节):通常 1 Byte = 8 bit。
  • KB、MB、GB、TB:常见容量单位。

在计算机基础题中,可能采用两种单位口径:

  • 十进制:1 KB = 1000 B,常见于硬盘厂商容量标注。
  • 二进制:1 KiB = 1024 B;很多基础教材或题目会把 1024 B 简写成 1 KB。

做题原则:先看题目给出的定义或换算口径,不要混用 1000 和 1024。

二进制换算示例(按 1024 口径):

  • 1 KB = 1024 Byte
  • 1 MB = 1024 KB
  • 1 GB = 1024 MB
  • 1 TB = 1024 GB

1.7 存储知识自测

  1. 计算机断电后,普通 RAM 中的数据通常还在吗?——不在。
  2. CPU 为了减少访问内存的等待,会使用什么高速存储?——Cache。
  3. U 盘通常使用什么介质?——闪存。
  4. 1 Byte 通常等于多少 bit?——8 bit。
  5. RAM 和 ROM 的主要区别之一是什么?——RAM 通常易失,ROM/非易失性固件存储断电仍能保存。

2. 计算机网络基础

2.1 计算机网络是什么

计算机网络是将多台计算机或设备通过通信线路和网络设备连接起来,使它们能够交换数据、共享资源和提供服务的系统。

常见设备:

  • 网卡:让设备接入网络。
  • 交换机:连接同一局域网内的设备,主要根据 MAC 地址转发数据。
  • 路由器:连接不同网络,依据 IP 地址等信息转发数据。
  • 无线接入点/AP:让无线设备接入网络。

2.2 按覆盖范围分类

类型英文覆盖范围例子
局域网LAN较小范围家庭、学校机房、办公室
城域网MAN城市范围城市范围的网络
广域网WAN很大范围跨城市、跨国家网络

记忆:LAN 小,MAN 城市,WAN 广域。

2.3 网络协议是什么

网络协议是设备之间通信时遵循的规则,规定数据如何组织、发送、接收和处理。

常见协议:

协议主要用途
HTTPWeb网页传输
HTTPS加密保护的 HTTP 通信
DNS将域名解析为 IP 地址
TCP可靠、有连接的数据传输
UDP无连接的数据传输,开销较小
IP寻址和数据包路由
SMTP发送电子邮件
FTP文件传输

二级重点是认识名称和基本作用,不必深入协议报文细节。

2.4 TCP/IP 四层模型

常见 TCP/IP 四层模型:

层次(自上而下)主要作用常见协议/例子
应用层为应用程序提供网络服务HTTP、HTTPS、DNS、SMTP、FTP
传输层端到端传输TCP、UDP
网际层IP 寻址、路由IP、ICMP
网络接口层在具体网络链路上传输数据Ethernet、Wi-Fi

2.5 OSI 七层模型

从上到下:

  1. 应用层:为用户应用提供网络服务。
  2. 表示层:数据格式、编码、加密等表示处理。
  3. 会话层:建立、管理和结束会话。
  4. 传输层:端到端传输。
  5. 网络层:逻辑寻址与路由。
  6. 数据链路层:相邻设备之间的数据帧传输。
  7. 物理层:比特流在物理介质上传输。

记忆口诀(从下往上):物理、数据链路、网络、传输、会话、表示、应用。

2.6 两种模型的粗略对应

TCP/IP 四层OSI 七层大致对应
应用层应用层、表示层、会话层
传输层传输层
网际层网络层
网络接口层数据链路层、物理层

不同教材可能使用不同的 TCP/IP 分层表述,考试按题目给出的模型定义判断。

2.7 IP 地址

  • IP 地址用于在 IP 网络中标识网络接口。
  • 常见 IPv4 地址由 32 位二进制组成,通常写成四段十进制数,例如 192.168.1.10。
  • 每段通常在 0~255 之间。
  • IPv6 地址长度为 128 位,通常用十六进制表示。

子网掩码用于区分 IP 地址中的网络部分和主机部分。例如常见的 255.255.255.0 对应 /24,表示前 24 位为网络前缀。

基础判断:

  • 192.168.1.10 是常见私有 IPv4 地址形式。
  • 127.0.0.1 是 IPv4 回环地址,常用于表示本机。
  • IP 地址与域名不是同一个概念;DNS 可以帮助把域名解析为 IP 地址。

常见的私有 IPv4 地址段(不需要背精确范围,知道哪些是私有即可):

地址段开头说明
10.x.x.xA 类私有
172.16.x.x ~ 172.31.x.xB 类私有
192.168.x.xC 类私有(家庭路由器最常见)
127.x.x.x回环地址(本机)

考试常见问法:以下哪个 IP 是私有地址?192.168.1.1 是私有地址吗?127.0.0.1 表示什么?

2.8 域名

域名是便于人记忆的网络名称,例如 www.example.com。DNS 负责把域名解析为 IP 地址。

域名从右向左看层级。www.gesp.ccf.org.cn 中,最右侧的 cn 是顶级域名。

2.9 浏览器访问网页的完整流程(常考)

在浏览器输入网址到看到网页,大致经过以下步骤:

  1. 输入网址:用户在浏览器输入域名或网址。
  2. DNS 解析:浏览器通过 DNS 把域名解析成对应的 IP 地址。
  3. 建立连接:浏览器与服务器通过 TCP/IP 协议建立连接。
  4. 发送请求:浏览器向服务器发送 HTTP(或 HTTPS)请求。
  5. 服务器响应:服务器把网页内容(HTML、图片等)传回给浏览器。
  6. 浏览器渲染:浏览器解析并显示网页。

考试常见问法:DNS 的作用是什么?输入域名后,计算机需要先做什么才能访问服务器?

3. 程序设计语言与编译

3.1 机器语言

  • 由二进制指令组成。
  • 计算机硬件可以直接执行。
  • 对人来说不容易阅读和编写。
  • 与具体处理器架构关系密切。

3.2 汇编语言

  • 使用助记符表示机器指令。
  • 比机器语言更容易阅读。
  • 通常需要汇编程序转换成机器代码。
  • 与处理器指令集关系密切。

3.3 高级语言

  • 更接近人类表达习惯。
  • 便于编写、阅读和维护。
  • C++、Python、Java 等都属于高级语言。
  • 通常需要编译器或解释器等工具处理。

3.4 编译型语言与解释型语言

高级语言按执行方式可以分为两大类:

类型工作方式特点代表语言
编译型先用编译器把源代码整体翻译成机器代码,再运行运行速度快;修改后需重新编译C、C++
解释型运行时由解释器逐行翻译并执行修改后直接运行,方便;速度通常较慢Python、JavaScript

考试常见问法:C++ 属于编译型还是解释型?编译型和解释型的主要区别是什么?

记忆:C/C++ = 编译型 = 先翻译再运行;Python = 解释型 = 边翻译边运行。

3.5 C++ 程序运行的基本过程

常见过程:

  1. 编写源代码。
  2. 编译源代码,检查语法并生成目标代码。
  3. 链接需要的库和目标代码,形成可执行程序。
  4. 运行程序,输入数据并得到输出。

常见概念:

  • 编译:把源代码转换为目标代码的过程。
  • 编译器:执行编译工作的程序。
  • 语法错误:代码不符合语言规则。
  • 运行错误:程序运行时发生异常或非法操作。
  • 逻辑错误:程序能运行,但结果不符合题目要求。
  • 调试:查找和修正程序错误。

4. 流程图

4.1 流程图的作用

流程图用图形符号和箭头表示程序或工作的执行步骤,帮助人理解程序的执行顺序和判断关系。

4.2 常见符号

符号形状名称用途
椭圆开始/结束框表示流程开始或结束
平行四边形输入/输出框输入数据、输出结果
矩形处理框赋值、计算等处理
菱形判断框根据条件选择不同分支
箭头流程线表示执行方向

4.3 三种基本程序结构

三种基本结构都可以用「椭圆(起止)+ 平行四边形(输入输出)+ 矩形(处理)+ 菱形(判断)」这四类符号组合表示。下面用流程图语法画出标准图形(在 Typora、VS Code、语雀、GitHub 等支持 Mermaid 的编辑器中会渲染成真正的图形)。

顺序结构:按从上到下的顺序执行,只有一条路径,没有判断分支。

flowchart TD
    A([开始]) --> B[/输入 a,b/]
    B --> C[sum = a + b]
    C --> D[/输出 sum/]
    D --> E([结束])

符号含义:椭圆是开始/结束框,平行四边形是输入/输出框,矩形是处理框。

选择结构:根据条件选择执行路径,菱形是判断框。

flowchart TD
    A([开始]) --> B{条件成立?}
    B -- 是 --> C[执行 A]
    B -- 否 --> D[执行 B]
    C --> E([结束])
    D --> E

符号含义:菱形表示判断,从菱形引出「是」「否」两条分支,最后汇合到结束。

循环结构:条件满足时重复执行某个过程,菱形判断不成立时结束循环。

flowchart TD
    A([开始]) --> B{循环条件成立?}
    B -- 是 --> C[执行循环体]
    C --> B
    B -- 否 --> D([结束])

符号含义:菱形判断条件,条件为「是」时执行循环体并回到判断,为「否」时结束循环。

4.4 流程图与代码对应

流程图含义C++ 常见写法
输入cin >> x;
输出cout << x;
赋值/计算sum = a + b;
条件判断if (...)
条件重复while (...)
次数范围循环for (...)

5. ASCII 编码

5.1 什么是编码

计算机内部使用数字表示字符。ASCII 是一种字符编码标准,为英文字母、数字、标点和控制字符分配数值。

5.2 必须记住的字符

字符十进制编码
空格32
数字字符 '0'48
数字字符 '1'49
数字字符 '9'57
大写字母 'A'65
大写字母 'Z'90
小写字母 'a'97
小写字母 'z'122

5.3 字符与整数互相转换

char c = 'A';
int x = c;
cout << x; // 65
int x = 66;
char c = x;
cout << c; // B

5.4 数字字符转整数

char c = '8';
int x = c - '0'; // 8

反过来:

int x = 8;
char c = x + '0'; // '8'

5.5 易错点

char c = 'C';
cout << c + 2;

输出的是整数 69,不是字符 E,因为 c+2 发生整数运算,结果类型为整数。

如果要输出字符:

cout << char(c + 2); // E

6. 数据类型转换

6.1 隐式类型转换

由编译器根据表达式规则自动进行。

int a = 5;
double b = a; // int 自动转换为 double

6.2 强制类型转换

程序员明确要求转换。

double x = 3.9;
int a = (int)x; // a 为 3

也可以写:

int a = static_cast<int>(x);

6.3 整数与浮点数混合运算

int a = 5, b = 2;
cout << a / b;          // 2
cout << (double)a / b;  // 2.5

只把最终结果赋给 double,不能挽回前面已经发生的整数除法:

double x = a / b; // x 是 2.0,不是 2.5

6.4 类型转换注意事项

  • 浮点数转换为整数时,小数部分被截去,不是四舍五入。
  • 大类型转换为小类型可能丢失信息。
  • char 与整数可以相互转换,字符对应其编码值。
  • 比较浮点数时,某些题目需要考虑精度误差;按题目数据范围和要求处理。
  • 乘法可能在赋值之前就溢出,所以需要在计算前就使用足够大的类型。

7. 多层分支结构

7.1 if 嵌套

if (x >= 0) {
    if (x == 0) {
        cout << "zero";
    } else {
        cout << "positive";
    }
} else {
    cout << "negative";
}

理解方法:先判断外层条件,再进入对应的大括号判断内层条件。

7.2 switch 嵌套与 break

switch (choice) {
    case 1:
        if (x > 0) cout << "positive";
        else cout << "not positive";
        break;
    case 2:
        cout << "other";
        break;
    default:
        cout << "invalid";
}

7.3 闰年判断(多层分支经典题)

闰年规则:

  • 能被 400 整除的是闰年;
  • 能被 4 整除但不能被 100 整除的也是闰年;
  • 其余不是闰年。
int y;
cin >> y;

if (y % 400 == 0 || (y % 4 == 0 && y % 100 != 0)) {
    cout << "闰年";
} else {
    cout << "平年";
}

要点:%400==0 和 (y%4==0 && y%100!=0) 用 || 连接,&& 的优先级高于 ||,所以括号可以省略,但加上括号更清晰、更不容易错。

7.4 条件优先级

常见优先顺序(只列常用部分):

  1. 括号 ()
  2. 一元运算 !、正负号、++、--
  3. *、/、%
  4. +、-
  5. 比较 <、<=、>、>=
  6. 相等 ==、!=
  7. 逻辑与 &&
  8. 逻辑或(双竖线)
  9. 赋值 =、+= 等

不确定时主动加括号,能显著减少错误。

特别注意:

  • = 是赋值,== 是判断相等,两者完全不同。
  • && 是并且,逻辑或是或者。
  • a < b < c 在 C++ 中不是数学上的连续比较,应写成 a < b && b < c。

8. 多层循环结构

8.1 循环次数

for (int i = 1; i <= 10; i++) {
    // 执行10次
}

i=1 到 i=10,一共 10 次。

for (int i = 0; i < 10; i++) {
    // 也执行10次
}

i=0 到 i=9,一共 10 次。

8.2 双重循环总次数

for (int i = 1; i <= 3; i++) {
    for (int j = 1; j <= 4; j++) {
        cout << i << j << '\n';
    }
}

内层每次执行 4 次,外层执行 3 次,总共 3×4=12 次。

8.3 循环中的 break

break 只结束它所在的最内层循环,不会自动结束所有外层循环。

8.4 循环中的 continue

continue 跳过当前这一轮循环体中剩余的语句,继续下一轮。对于 for 循环,会继续执行更新表达式后再判断条件。

8.5 死循环

while (true) {
    // 如果没有退出条件,可能一直运行
}
int i = 1;
while (i <= 10) {
    cout << i;
    // 忘记 i++,会一直输出 1
}

阅读循环程序时,必须检查循环变量是否会改变,以及是否有可能永远满足循环条件。

9. 常见数学函数与算法思想

9.1 绝对值 abs

int d = abs(a - b);

9.2 平方根 sqrt

double x = sqrt(25.0); // 5.0

9.3 最大值、最小值

int bigger = max(a, b);
int smaller = min(a, b);

9.4 随机数 rand

int x = rand() % 6 + 1; // 1~6

如果要让不同运行时的伪随机序列尽量不同,可以用时间设置种子。考试中通常重点是理解函数含义与范围,不是随机数算法本身。

9.5 枚举

枚举就是把可能的情况逐一尝试,再判断是否满足条件。

for (int x = 1; x <= 100; x++) {
    if (x % 7 == 0) {
        cout << x << ' ';
    }
}

适合数据范围不大、可能情况可以逐一检查的题目。

9.6 模拟

模拟就是按照题目给定的规则,一步一步在程序中执行。

典型例子:时间推进、数字变化、能量增减、游戏规则、循环过程。

模拟题常见错误:顺序写错、边界漏判、更新变量时使用了已经改变的值。

10. 二级范围边界与延伸知识说明

以下内容可能在孩子此前学习或个别题目中接触过,但不是本次二级考纲主线,不建议在考前投入大量时间:

  • 数组、二维数组的系统应用;
  • 字符串算法;
  • 函数与递归的系统学习;
  • 排序、二分查找;
  • STL 容器;
  • DFS/BFS、动态规划等算法。

但 B4576 这道 2026 年 9 月二级真题明确给出 8×16 画布,可以把它作为按题目需要使用固定大小字符网格的专项。只需理解行列编号和字符赋值,不必扩展成数组算法课程。

B4576 画布坐标与 ASCII 专项示例

B4576(2026 年 9 月二级真题)给出一块 8 行 16 列的画布,初始填满某种字符,随后给出若干次修改操作:每次操作告诉你要改的格子编号和要填入的字符。核心是两步:

  1. 把格子编号换算成行、列坐标;
  2. 把字符(或 ASCII 编码)写到对应位置。

第一步:编号转坐标。 8 行 16 列,共 128 个格子,编号从 1 开始。编号 k 对应(从 0 开始的下标):

  • 行下标:(k - 1) / 16
  • 列下标:(k - 1) % 16

如果用从 1 开始的行列:

  • 行号:(k - 1) / 16 + 1
  • 列号:(k - 1) % 16 + 1

第二步:把字符写到对应格子。 参考实现思路(示例,非原题完整代码,实际以题面输入格式为准):

#include <bits/stdc++.h>
using namespace std;

int main() {
    char board[8][16];

    // 1. 初始化画布(假设初始填满点号 '.',具体字符以题目为准)
    for (int i = 0; i < 8; i++) {
        for (int j = 0; j < 16; j++) {
            board[i][j] = '.';
        }
    }

    // 2. 处理若干次修改:每次读入「格子编号 pos」和「要填的字符 ch」
    int m;          // 修改次数(具体数量以题目为准)
    cin >> m;
    for (int t = 0; t < m; t++) {
        int pos;
        char ch;
        cin >> pos >> ch;       // 读入格子编号和要填的字符

        int row = (pos - 1) / 16;   // 换算行下标
        int col = (pos - 1) % 16;   // 换算列下标

        board[row][col] = ch;       // 把字符写到对应格子
    }

    // 3. 输出整块画布
    for (int i = 0; i < 8; i++) {
        for (int j = 0; j < 16; j++) {
            cout << board[i][j];
        }
        cout << '\n';
    }

    return 0;
}

关键提醒:

  • 编号转坐标用 (pos-1)/16 和 (pos-1)%16,不要漏掉 -1,因为编号从 1 开始、下标从 0 开始。
  • 如果题目给的是「ASCII 编码」而不是「字符本身」,就把读入的整数用 char(编码) 转成字符再填入,例如 board[row][col] = char(code);。
  • 这段只是说明思路的示例,具体画布大小、初始字符、修改次数和输入格式,都要以 B4576 原题题面为准。

11. 程序阅读方法:手工模拟,不要只凭感觉

程序阅读题的核心是跟踪变量变化。建议使用表格记录:

步骤isum条件结果执行语句
第1轮10......
第2轮2.........

阅读顺序:

  1. 先找变量初始值。
  2. 找到循环的开始条件。
  3. 每轮按代码从上到下执行。
  4. 遇到 if,先算条件真假。
  5. 遇到 continue,跳过本轮剩余语句。
  6. 遇到 break,结束当前循环。
  7. 一轮结束后,再执行 for 更新表达式。
  8. 循环结束后检查输出语句。

11.1 阅读题例一:累加满足条件的数

int sum = 0;
for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0) {
        sum += i;
    }
}
cout << sum;

分析:只加偶数 2、4、6、8、10。

结果:30。

11.2 阅读题例二:continue

int sum = 0;
for (int i = 1; i <= 6; i++) {
    if (i % 2 == 0) {
        continue;
    }
    sum += i;
}
cout << sum;

分析:偶数跳过,只累加 1、3、5。

结果:9。

11.3 阅读题例三:break

int sum = 0;
for (int i = 1; i <= 10; i++) {
    if (i == 5) {
        break;
    }
    sum += i;
}
cout << sum;

分析:i 等于 5 时退出,因此只加 1、2、3、4。

结果:10。

11.4 阅读题例四:双重循环

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

分析:外层 3 次,内层每次 2 次,总共 6 次。

结果:6。

11.5 阅读题例五:整数除法

int a = 7;
int b = 2;
double x = a / b;
cout << x;

分析:先进行整数除法 7/2,两个操作数都是 int,结果丢弃小数部分得到整数 3;再赋值给 double x,x 的值为 3.0(不是 2.5)。

结果:3(默认输出可能不显示小数点;用 fixed 设置后可能显示为 3.000000)。关键点:结果不是 2.5,因为整数除法在赋值给 double 之前就已经发生了。

11.6 阅读题例六:字符编码

char c = 'A';
int x = c + 2;
cout << x << ' ' << char(x);

分析:'A' 的 ASCII 是 65,65+2=67。

结果:67 C。

11.7 阅读题例七:嵌套 if

int x = 12;
if (x > 10) {
    if (x % 2 == 0) {
        cout << "A";
    } else {
        cout << "B";
    }
} else {
    cout << "C";
}

分析:12 大于 10,进入外层;12 是偶数,输出 A。

结果:A。

11.8 阅读题例八:变量更新顺序陷阱

int a = 3, b = 5;
a = a + b;       // a 变成 8,b 还是 5
b = a - b;       // b 变成 8-5=3,a 还是 8
a = a - b;       // a 变成 8-3=5,b 还是 3
cout << a << ' ' << b;

分析:这是不用临时变量交换两个数的经典写法。关键在于每一行执行后,a 和 b 的值都在变化,下一行用的是已经更新后的值。

步骤ab执行语句
初始35—
第1行后85a = a + b
第2行后83b = a - b
第3行后53a = a - b

结果:5 3(a 和 b 的值交换了)。

这类题是阅读题最爱挖坑的地方:一定要用表格逐行记录变量变化,不能凭脑算。

未经允许不得转载:编源视界 » GESP C++ 二级复习资料:常用代码模板、核心考点

相关推荐

    暂无内容!