GESP 五级及以上

[从佳晨]

C++ GESP 五级~八级 完整知识点总结（5000字+知识点代码分块版）

前言

本文严格对标GESP 五级~八级官方考纲，按照指针→结构体→文件操作→进阶函数→递归→面向对象→STL基础→算法进阶的逻辑层层递进，纯知识点在上，配套代码独立分块，逻辑清晰、标号系统、考点全覆盖，适配考级备考、竞赛入门、系统学习。全文约5200字。

---

第一部分：GESP 五级核心知识点（指针+结构体）

一、指针基础（五级核心）

1.1 核心知识点

1. 指针本质：存储变量内存地址的变量，用于间接访问数据。
2. 定义格式：数据类型 *指针名;，如int *p;。
3. 核心运算符：
   • &：取地址符，获取变量地址；
   • *：解引用符，通过地址访问变量值。
4. 空指针：NULL，表示指针不指向任何有效地址。
5. 指针与数组：数组名是首地址指针，a[i]等价于*(a+i)。
6. 指针大小：固定8字节（64位系统），与类型无关。

1.2 配套代码块

// 1. 指针基本用法
#include <iostream>
using namespace std;
int main() {
    int a = 10;
    int *p = &a;  // p存储a的地址
    cout << *p << endl;  // 解引用，输出10
    *p = 20;  // 修改a的值
    cout << a << endl;  // 输出20
    return 0;
}

// 2. 指针与数组
int main() {
    int arr[5] = {1,2,3,4,5};
    int *p = arr;
    cout << *(p+2) << endl;  // 等价arr[2]，输出3
    return 0;
}

---

二、指针与函数（五级核心）

2.1 核心知识点

1. 地址传递：函数形参为指针，修改实参本身（区别于值传递）。
2. 指针作为函数参数：实现函数内修改外部变量。
3. 数组作函数参数：本质是指针传递。
4. const指针：const int *p（不能修改值），int *const p（不能修改地址）。

2.2 配套代码块

// 1. 地址传递：交换两个数
void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}
int main() {
    int x=3, y=5;
    swap(&x, &y);
    cout << x << " " << y;  // 输出5 3
    return 0;
}

---

三、结构体（五级核心）

3.1 核心知识点

1. 结构体：自定义复合数据类型，可存储不同类型数据。
2. 定义格式：struct 结构体名{ 成员列表; };。
3. 访问成员：
   • 普通变量：. 成员运算符；
   • 指针变量：-> 箭头运算符。
4. 结构体数组：存储多个结构体数据。
5. 结构体作函数参数：可值传递/地址传递。

3.2 配套代码块

// 1. 结构体定义与使用
struct Student {
    int id;
    string name;
    int score;
};
int main() {
    Student s = {101, "张三", 95};
    cout << s.name << " " << s.score << endl;
    return 0;
}

// 2. 结构体指针
int main() {
    Student s = {102, "李四", 88};
    Student *p = &s;
    cout << p->name;  // 箭头访问
    return 0;
}

---

第二部分：GESP 六级核心知识点（文件+字符串+进阶函数）

四、文件操作（六级核心）

4.1 核心知识点

1. 文件分类：文本文件、二进制文件（考级只考文本文件）。
2. 头文件：#include <fstream>。
3. 文件流类：
   • ifstream：读文件；
   • ofstream：写文件；
   • fstream：读写文件。
4. 操作步骤：打开文件→读写数据→关闭文件。
5. 打开模式：ios::in读，ios::out写，ios::app追加。
6. 判断文件是否打开成功：if(!文件对象) exit(0);。

4.2 配套代码块

// 1. 写文件
#include <fstream>
int main() {
    ofstream fout("test.txt");  // 打开文件
    fout << "Hello GESP" << endl;
    fout << 123 << endl;
    fout.close();  // 关闭
    return 0;
}

// 2. 读文件
int main() {
    ifstream fin("test.txt");
    string s; int num;
    fin >> s >> num;
    cout << s << " " << num;
    fin.close();
    return 0;
}

---

五、string字符串类（六级核心）

5.1 核心知识点

1. 区别于字符数组：string是安全字符串，自动管理内存。
2. 常用操作：
   • 赋值：s1 = s2；
   • 拼接：s1 + s2；
   • 比较：==、!=、>；
   • 长度：s.size()/s.length()；
   • 访问字符：s[i]。
3. 常用函数：
   • s.substr(pos, len)：截取子串；
   • s.find(str)：查找子串位置；
   • s.insert(pos, str)：插入字符串。

5.2 配套代码块

#include <iostream>
#include <string>
using namespace std;
int main() {
    string s = "abc123";
    cout << s.size() << endl;  // 长度6
    cout << s.substr(0,3) << endl;  // 输出abc
    cout << s.find("123") << endl;  // 输出3
    return 0;
}

---

六、函数进阶（六级核心）

6.1 核心知识点

1. 函数重载：同名函数，参数不同（个数/类型/顺序）。
2. 默认参数：函数形参设置默认值，调用可省略实参。
3. 内联函数：inline，减少函数调用开销，适合短函数。
4. 作用域：局部变量、全局变量、静态变量static。
5. 静态变量：函数结束不释放，只初始化一次。

6.2 配套代码块

// 1. 函数重载
int add(int a, int b) { return a+b; }
double add(double a, double b) { return a+b; }

// 2. 默认参数
void show(int a=10) { cout << a; }

// 3. 静态变量
void test() {
    static int x=0;
    x++; cout << x;
}
int main() {
    test(); test();  // 输出12
    return 0;
}

---

第三部分：GESP 七级核心知识点（递归+动态内存+算法）

七、递归函数（七级核心）

7.1 核心知识点

1. 递归：函数自己调用自己，必须有边界条件。
2. 两要素：递归公式 + 递归出口。
3. 经典题型：阶乘、斐波那契、求和、数字反转、迷宫问题。
4. 执行原理：栈调用，先递推，再回归。
5. 优缺点：代码简洁，但效率低于循环。

7.2 配套代码块

// 1. 阶乘递归
int fact(int n) {
    if(n==0) return 1;  // 出口
    return n * fact(n-1);
}

// 2. 斐波那契
int fib(int n) {
    if(n<=2) return 1;
    return fib(n-1)+fib(n-2);
}

---

八、动态内存分配（七级核心）

8.1 核心知识点

1. 作用：程序运行时手动申请/释放内存，灵活管理空间。
2. 关键字：
   • new：申请内存；
   • delete：释放内存。
3. 用法：
   • 单个变量：int *p = new int;
   • 数组：int *arr = new int[10];
4. 内存泄漏：只new不delete，必须成对使用。
5. 空指针释放：安全，无副作用。

8.2 配套代码块

// 1. 动态变量
int main() {
    int *p = new int(100);
    cout << *p;
    delete p;  // 释放
    p = NULL;
    return 0;
}

// 2. 动态数组
int main() {
    int n; cin >> n;
    int *arr = new int[n];
    for(int i=0; i<n; i++) arr[i]=i;
    delete[] arr;  // 数组释放
    return 0;
}

---

九、进阶算法（七级核心）

9.1 核心知识点

1. 二分查找：有序数组才能使用，效率远高于顺序查找。
2. 选择排序：每次选最小/最大值放到指定位置。
3. 插入排序：将元素插入到前面有序序列。
4. 字符统计、字符串处理、结构体排序。
5. 算法复杂度：二分O(logn)，冒泡/选择/插入O(n²)。

9.2 配套代码块

// 1. 二分查找
int binarySearch(int arr[], int n, int target) {
    int l=0, r=n-1;
    while(l<=r) {
        int mid = (l+r)/2;
        if(arr[mid]==target) return mid;
        else if(arr[mid]<target) l=mid+1;
        else r=mid-1;
    }
    return -1;
}

// 2. 选择排序
void selectSort(int a[], int n) {
    for(int i=0; i<n-1; i++) {
        int minPos=i;
        for(int j=i+1; j<n; j++)
            if(a[j]<a[minPos]) minPos=j;
        swap(a[i],a[minPos]);
    }
}

---

第四部分：GESP 八级核心知识点（面向对象+类与对象+封装）

十、类与对象（八级核心）

10.1 核心知识点

1. 面向对象三大特性：封装、继承、多态（GESP八级只考封装）。
2. 类：对象的模板，包含属性（成员变量）和行为（成员函数）。
3. 对象：类的实例，类名 对象名;。
4. 访问权限：
   • public：公开，外部可访问；
   • private：私有，仅类内部可访问（默认）。
5. 封装：将属性私有化，提供公有函数访问/修改。
6. 构造函数：创建对象时自动调用，初始化对象。
7. 析构函数：对象销毁时自动调用，释放资源，~类名()。

10.2 配套代码块

// 类的定义与封装
class Student {
private:
    // 私有属性
    int id;
    string name;
public:
    // 构造函数
    Student(int i, string n) {
        id = i;
        name = n;
    }
    // 公有成员函数
    void show() {
        cout << id << " " << name << endl;
    }
};
int main() {
    Student s(101, "小明");
    s.show();
    return 0;
}

---

十一、成员函数与构造函数（八级核心）

11.1 核心知识点

1. 默认构造函数：无参数，系统自动提供。
2. 有参构造函数：自定义初始化。
3. 拷贝构造函数：用已有对象创建新对象。
4. 析构函数：无参无返回值，一个类只有一个。
5. this指针：指向当前对象，区分同名变量。
6. 结构体vs类：结构体默认public，类默认private。

11.2 配套代码块

class Point {
private:
    int x, y;
public:
    Point() { x=0; y=0; }  // 默认构造
    Point(int x, int y) {  // 有参构造
        this->x = x;
        this->y = y;
    }
    void print() { cout << x << " " << y; }
};

---

十二、STL基础（八级拓展）

12.1 核心知识点

1. STL：C++标准模板库，提供常用数据结构与算法。
2. vector动态数组：自动扩容，替代普通数组。
3. 常用函数：push_back()、size()、[]、clear()。
4. sort排序函数：sort(arr,arr+n)快速排序。
5. 适合考级：简化代码，提高效率。

12.2 配套代码块

#include <vector>
#include <algorithm>
int main() {
    vector<int> v;
    v.push_back(3);
    v.push_back(1);
    v.push_back(2);
    sort(v.begin(), v.end());  // 排序
    for(int i=0; i<v.size(); i++)
        cout << v[i] << " ";
    return 0;
}

---

十三、综合算法与编程思想（八级必考）

13.1 核心知识点

1. 模块化编程：函数+类+结构体分工协作。
2. 结构体+排序+文件综合题。
3. 递归+分治思想：二分、快速排序思想。
4. 内存安全：new/delete配对，避免空指针。
5. 调试技巧：断点调试、中间变量输出、边界测试。

---

第五部分：GESP 5~8 等级考点总表

14.1 五级考点

指针基础、指针与数组、地址传递、结构体、结构体数组、指针与结构体。

14.2 六级考点

文件读写、string字符串、函数重载、默认参数、静态变量、const修饰符。

14.3 七级考点

递归函数、动态内存new/delete、二分查找、选择排序、插入排序、算法优化。

14.4 八级考点

类与对象、封装、访问权限、构造/析构函数、this指针、STL基础、综合项目。

---

结尾总结

本文完整覆盖GESP 五级~八级全部核心知识点，全文约5200字，严格遵循知识点在上、代码独立分块格式，逻辑清晰、标号统一、无冗余内容，完全适配考级备考要求。

学习主线：指针→结构体→文件→字符串→递归→动态内存→类与对象，逐级递进、由浅入深。掌握本总结所有知识点与代码，可轻松应对GESP五级至八级所有题型。

---

[董宇晟 (非洲矛蚁)]

好整理！爱了