简介：面向C++入门到进阶学习者的黑马程序员课程资料包，聚焦课堂教学与项目实战的衔接，适合希望系统梳理C++语法、面向对象编程及STL应用的自学者与在校学生。压缩包约64.14MB，内含课程文档手册、实验项目及多本PDF电子书，文件组织围绕基础学习与项目演练展开，便于按主题检索和阶段性复习。随附《InterviewGuide第四版By阿秀》《LeetCode刷题手册》《背包问题九讲》《算法图解》等PDF，可配合语法学习补充面试准备、算法训练与数据结构理解。三个实验项目由简到繁，分别为《通讯录管理系统》《职工管理系统》《基于STL的演讲比赛流程管理系统》，覆盖结构体与数组、类与对象、继承多态、STL容器与算法等知识点，能够帮助读者在完整项目中理解需求拆解、模块划分与代码组织。目前已有1697人学习下载，适合需要课程同步练习、项目复盘与查漏补缺的C++学习者。
1. 知识地图：这套 C++ 课程资源的六个台阶
很多人学 C++ 的方式是从第一集视频一路刷到最后一集，刷完发现代码看得懂、项目写不出。问题通常不在勤奋，而在于手里没有一张地图：不知道现在站的位置属于哪一层，也不知道下一层依赖什么。这份 C++ 课程资源真正的价值，是它把「语法 → 对象模型 → 内存 → 标准库 → 现代特性 → 项目实战」串成了一条有依赖关系的主线，而不是零散切片。下面按这条主线重拆一遍：先看整张地图有几个台阶，再逐层标出重点、难点和容易踩的坑，最后落成一份能直接照着走的复习清单。它适合两类人：正在系统学 C++、想把课程资源用透的；以及学过一遍、要捡起来应付笔试面试或接手项目的。
六个台阶的依赖关系是这样的：语法与面向对象是地基，决定你能不能读懂别人的类；内存与指针是分水岭，决定你写的东西会不会在半夜崩；STL 与模板是效率层，决定你写代码的速度；现代 C++ 特性与并发是加分项，也是面试区分度最高的地方；易错点是横切面，前面每一层都会踩；复习清单负责把这些收成可执行的路线。台阶之间有顺序，跳级的人最后都要回来补。
2. 语法地基与面向对象：从变量到多态的一条主线
语法部分最容易被轻视，因为「看得懂」和「写得对」之间隔着一堆隐式规则。面向对象部分则是最容易背下来的，因为多态、虚函数、继承这些词太熟，熟到很多人从没验证过虚函数表到底怎么摆、对象切片到底切掉了什么。这一章按「类型与表达式 → 类与三个默认函数 → 继承与多态 → 运算符重载与 const 正确性」四段推进，每段都落到能复现的细节上。
2.1 类型系统与表达式：隐式转换是最安静的错误源
内置类型的宽度和取值范围必须先钉死，因为后面所有指针运算、内存布局、序列化都建立在这张表上。
| 类型 | 典型宽度（字节） | 说明 |
|---|---|---|
| char | 1 | 是否带符号由实现决定，别拿它当小整数用 |
| short | 2 | 至少 16 位 |
| int | 4 | 绝大多数平台，但不是标准强制 |
| long | 4 或 8 | Windows 64 位是 4，Linux 64 位是 8，跨平台血泪点 |
| long long | 8 | 至少 64 位，序列化优先选它 |
| float / double | 4 / 8 | 有效精度约 7 位 / 15 位，比较必须带容差 |
最容易出事的不是宽度，而是隐式转换。整型提升会把char、short抬成int再运算；有符号和无符号混在一起时，有符号那个会被解释成无符号，负数直接变成极大的正数。下面这段倒序遍历就是经典翻车现场。
#include <vector> #include <cstddef> void printReverse(const std::vector<int>& v) { // 反例：size_t 是无符号，i >= 0 永远成立，i 减到 0 之后再减会回绕成极大值 for (std::size_t i = v.size() - 1; i >= 0; --i) { // ... } } void printReverseOk(const std::vector<int>& v) { // 正解一：用反向迭代器，语义最清楚 for (auto it = v.rbegin(); it != v.rend(); ++it) { /* ... */ } // 正解二：用有符号下标，注意空容器时 size()-1 仍会下溢，先判空 for (int i = static_cast<int>(v.size()) - 1; i >= 0; --i) { /* ... */ } }第一段的错误点在于循环条件和类型不匹配：i >= 0对无符号类型恒为真，编译器多半只给一条警告。修法有两种，反向迭代器更符合标准库习惯，有符号下标更贴近手写算法。参数上要注意v.size()返回的是std::size_t，强转int在超大容器上有截断风险，实际工程里更稳的写法是先判空再用i != 0配合i - 1取元素。
浮点比较同理，a == b在累加、除法之后几乎必然失效，正确做法是判断差值绝对值小于1e-9这类容差。位运算的优先级也值得单独记一遍：&低于==，所以if (x & 1 == 0)会被解析成x & (1 == 0)，加上括号是最省事的后悔药。
2.2 类与对象：三个默认函数的取舍
编译器会免费送你构造、拷贝构造、拷贝赋值、析构。这四个函数在类里没有裸指针时都很好用，一旦有了指针成员，默认版本就是浅拷贝，两个对象指向同一块堆内存，析构时重复释放。这就是所谓的三法则：需要自己写析构，通常也需要自己写拷贝构造和拷贝赋值。
#include <cstring> #include <utility> class Buffer { public: explicit Buffer(std::size_t n) // explicit 挡住 size_t 到 Buffer 的隐式转换 : data_(new char[n]), size_(n) {} ~Buffer() { delete[] data_; } // 拷贝构造：先分配自己的内存，再复制内容，避免两个对象共享同一块堆区 Buffer(const Buffer& other) : data_(new char[other.size_]), size_(other.size_) { std::memcpy(data_, other.data_, size_); } // 拷贝赋值：copy-and-swap，天然处理自赋值和异常安全 Buffer& operator=(const Buffer& other) { Buffer tmp(other); // 先构造副本，失败不影响 *this swap(tmp); // 交换后 tmp 析构时释放旧内存 return *this; } void swap(Buffer& other) noexcept { std::swap(data_, other.data_); std::swap(size_, other.size_); } private: char* data_; std::size_t size_; };拷贝构造里初始化列表的顺序必须和成员声明顺序一致，否则-Wreorder会提醒你。赋值运算符返回Buffer&是为了支持链式赋值，copy-and-swap的好处是把自赋值、内存分配失败、旧内存释放三件事一次性解决。如果类里再加一个移动构造和移动赋值，就是五法则；移动版本的参数是右值引用，直接偷走对方的指针并把对方置空，避免深拷贝。初始化列表与构造函数体内赋值的区别也要分清：const成员和引用成员只能在初始化列表里初始化，类类型成员写在初始化列表能省掉一次默认构造加赋值的开销。
static成员属于类而不属于对象，定义要放在类外（C++17 之后可以用inline static就地定义）。const成员函数承诺不修改对象状态，所以const对象只能调用const成员函数，这一点在传const&参数时特别容易漏。
2.3 继承与多态：虚函数表与对象切片
多态的实现机制是虚函数表：每个含虚函数的类有一张表，表里存着虚函数地址，对象头部藏一个指向这张表的指针。通过基类指针或引用调用虚函数时，运行时按对象的实际类型查表，这就是动态绑定；用对象本身调用则是静态绑定，编译期就定死了。
#include <iostream> #include <memory> #include <vector> class Shape { public: virtual ~Shape() = default; // 基类析构必须是虚的，否则 delete 派生类对象是未定义行为 virtual double area() const = 0; // 纯虚函数，Shape 变成抽象类，不能实例化 }; class Circle : public Shape { public: explicit Circle(double r) : r_(r) {} double area() const override { return 3.14159 * r_ * r_; } // override 让签名写错时直接编译报错 private: double r_; }; void demo() { std::vector<std::unique_ptr<Shape>> shapes; shapes.push_back(std::make_unique<Circle>(2.0)); for (const auto& s : shapes) { std::cout << s->area() << '\n'; // 动态绑定，走对象真实类型的 area() } }override和final这两个关键字建议无脑加，前者把「以为重写了其实写错参数」的坑挡在编译期，后者防止派生类继续改写。对象切片是另一个高频误区：把派生类对象按值赋给基类对象，派生类那部分成员会被直接切掉，虚函数表指针也变回基类的。
注意：在构造函数和析构函数里调用虚函数，不会发生动态绑定。构造基类时派生类部分还没建好，编译器只会调用当前类层次的版本。
多重继承会带来菱形问题：两个中间类继承同一个基类，最终类里就有两份基类子对象，解决方式是虚继承。但虚继承的布局和开销都不便宜，工程里更常见的做法是用组合代替多继承，接口隔离用纯虚基类（抽象接口）实现。
2.4 运算符重载与 const 正确性
运算符重载的原则只有一条：不要改变运算符的直觉语义。+就别拿来做减法，==重载了就该同时提供!=。能重载的运算符有限制，::、.、.*、?:、sizeof不能重载。
成员函数和非成员函数的选择有讲究：赋值类运算符（=、+=、[]、()）必须是成员；对称的二元运算符（==、+）更适合写成非成员，这样左右操作数都能参与隐式转换。前后缀++靠一个int占位参数区分，这是语法层面的约定。
class Counter { public: Counter& operator++() { // 前置：先加再用，返回引用支持链式 ++value_; return *this; } Counter operator++(int) { // 后缀：占位 int，返回旧值的副本 Counter old = *this; ++value_; return old; } int value() const { return value_; } // const 成员函数，const 对象也能调 private: int value_ = 0; };const的正确性是一条链：参数用const&避免拷贝，成员函数能加const就加，返回值能返回const引用就别返回值。例外是需要在const函数里修改的缓存类成员，用mutable标记，但别滥用，它会把「这个函数真的不改状态」的承诺打折扣。
3. 内存、指针与智能指针：C++ 的分水岭
语法写得再漂亮，内存一错全白搭。这一层是 C++ 与多数语言真正的分界线：栈和堆的区别、指针和引用的区别、new和delete的配对、内存泄漏和悬垂指针，这些概念不难，难在写的时候每一行都要过脑子。这一章从内存分区讲到智能指针，中间用 RAII 串起来，最后落到移动语义。
3.1 内存分区与对象的生命周期
| 区域 | 存放内容 | 生命周期 | 典型问题 |
|---|---|---|---|
| 栈 | 局部变量、函数参数、返回地址 | 随作用域自动回收 | 栈溢出、返回局部变量地址 |
| 堆 | new/malloc分配的内存 | 手动释放 | 泄漏、重复释放、悬垂指针 |
| 全局/静态区 | 全局变量、static变量 | 程序全程 | 初始化顺序不确定 |
| 常量区 | 字符串字面量、const全局量 | 程序全程 | 试图修改字面量 |
| 代码区 | 函数体的机器指令 | 程序全程 | 一般不用关心 |
栈的大小通常只有几 MB，递归太深或者在栈上开大数组会直接崩；堆受限于系统可用内存，但分配释放有开销，而且频繁小块分配会产生碎片。全局变量的初始化顺序跨编译单元是不确定的，工程上常用「函数内静态局部变量」来规避，因为 C++11 之后局部静态变量的初始化是线程安全的。
返回局部变量的地址是典型的悬垂指针来源：函数返回时栈帧销毁，指针指向的内存内容随时会被覆盖。同理，std::string::c_str()或vector::data()返回的裸指针，在容器扩容或析构后立刻失效。
3.2 指针、引用与 const 的三种位置
指针和引用常被拿来比较，区别集中在这几条：
| 维度 | 指针 | 引用 |
|---|---|---|
| 是否可为空 | 可以 | 不可以 |
| 是否可重新绑定 | 可以改指向 | 绑定后不能换 |
| 是否占内存 | 占一个机器字长 | 通常被优化掉，语义上是别名 |
| 是否必须初始化 | 可以不初始化（危险） | 必须初始化 |
| 算术运算 | 支持 | 不支持 |
const的位置决定它修饰谁，这是考试和面试的常客：const int* p是指向常量的指针，指针本身能改、指向的内容不能改；int* const p是常量指针，指针不能改、内容能改；const int* const p两者都不能改。读法是「const 在*左边修饰内容，在*右边修饰指针」。
指针数组和数组指针也容易绕：int* a[10]是数组，装了 10 个指针；int (*a)[10]是指针，指向一个含 10 个 int 的数组。函数指针的写法同理，int (*fp)(int, int)声明一个指向「两个 int 参数、返回 int」的函数的指针，typedef或using能显著提升可读性。
3.3 new/delete 与常见内存错误
new做两件事：调operator new分配内存，再调构造函数；delete反过来，先调析构再释放内存。数组版本必须配对使用new[]和delete[]，混用是未定义行为，因为数组的内存布局前面通常还存了元素个数。
void leakDemo() { int* p = new int[100]; // 忘记 delete[] p; —— 每次调用泄漏 400 字节，长跑服务里会慢慢吃满内存 } void danglingDemo() { int* p = new int(10); delete p; *p = 20; // 悬垂指针：内存已归还，再写就是踩别人的数据 p = nullptr; // 释放后立刻置空，是最便宜的保险 }内存泄漏的排查思路：先用工具定位（Linux 下 Valgrind 或编译期加 AddressSanitizer），再回到代码看所有权归属。重复释放和越界写更隐蔽，往往表现为「程序在别的地方莫名其妙崩了」，因为堆的元数据被踩坏了。RAII 是这一切的正解：把资源（内存、文件句柄、锁、socket）的获取放在构造函数里，释放放在析构里，让作用域结束自动回收，从此不用手写delete。
3.4 智能指针与移动语义
三种智能指针的分工很清晰：unique_ptr独占所有权，不能拷贝只能移动，零额外开销；shared_ptr共享所有权，内部维护引用计数，计数归零才释放；weak_ptr不增加计数，用来观察shared_ptr管理的对象，专门解决循环引用。
#include <memory> struct Node { std::shared_ptr<Node> next; std::weak_ptr<Node> prev; // 反向指针用 weak_ptr，打断循环引用 }; void buildList() { auto a = std::make_shared<Node>(); auto b = std::make_shared<Node>(); a->next = b; b->prev = a; // 如果这里也用 shared_ptr，两个节点计数永远为 1，谁都不释放 }make_shared比shared_ptr<T>(new T)更推荐，它把控制块和对象分配在一块连续内存里，少一次分配，也避免了异常安全上的缝隙。shared_ptr的计数操作是原子的，但对象本身的读写不是线程安全的，多线程改同一个对象仍然要加锁。
移动语义解决的是「临时对象没必要深拷贝」的问题。右值引用T&&让函数能识别出「这个对象马上要死了」，于是直接接管它的资源。std::move本身不移动任何东西，它只是一个类型转换，把左值转成右值引用，真正的移动发生在移动构造或移动赋值里。
#include <string> #include <utility> #include <vector> void moveDemo() { std::vector<std::string> v; std::string s = "a-very-long-string"; v.push_back(std::move(s)); // 移动构造：s 的缓冲区被接管，s 变成有效的空串 // 此后不要再读 s 的内容，标准只保证它处于「有效但未指定」的状态 }移动之后的源对象只能析构或重新赋值，这个约定踩过一次就会记住。另外，移动构造和移动赋值要标noexcept，否则vector扩容时会退回到拷贝，因为标准库要保证异常安全。
4. STL、模板与标准库并发：效率层的三个抓手
手写链表和排序是学习阶段的事，工程里绝大多数场景都该用标准库。这一章的重点不是背接口，而是三件事：容器怎么选、迭代器什么时候失效、模板怎么用不炸。最后补上标准库的线程支持，把并发这块面试高频区一并过掉。
4.1 三大组件与容器选择
STL 的结构是容器、迭代器、算法三层分离：容器管存储，迭代器管遍历，算法管操作，三者靠迭代器协议解耦。容器选择的判断标准是「访问模式 + 插入删除位置 + 是否需要有序」。
| 容器 | 底层结构 | 随机访问 | 插入删除 | 适用场景 |
|---|---|---|---|---|
vector | 连续数组 | O(1) | 尾部均摊 O(1)，中间 O(n) | 默认首选，缓存友好 |
deque | 分段连续 | O(1) | 头尾 O(1) | 双端队列、滑动窗口 |
list | 双向链表 | 不支持 | 已知位置 O(1) | 频繁中间插入、元素大且拷贝贵 |
map/set | 红黑树 | 不支持 | O(log n) | 需要有序遍历、范围查询 |
unordered_map/unordered_set | 哈希表 | 不支持 | 均摊 O(1) | 纯查找，不关心顺序 |
priority_queue | 堆 | 仅堆顶 | O(log n) | Top-K、调度 |
vector是绝大多数场景的默认答案，因为连续内存对 CPU 缓存友好，实测往往比链表快一个数量级，哪怕理论复杂度更差。unordered_map的常数项不小，元素只有几十个时map甚至更快，别迷信哈希。自定义类型放进关联容器需要提供比较函数，放进哈希容器需要提供哈希函数和operator==。
4.2 迭代器失效的四条规律
迭代器失效是 STL 最容易翻车的地方，因为编译器不会提醒你，程序只是偶尔给出错误结果。
#include <vector> #include <map> void eraseDemo() { std::vector<int> v{1, 2, 3, 4, 5}; for (auto it = v.begin(); it != v.end(); ) { if (*it % 2 == 0) { it = v.erase(it); // erase 返回下一个有效迭代器，必须接住 } else { ++it; } } // 反例：for (auto it = v.begin(); it != v.end(); ++it) v.erase(it); —— it 已失效 }规律可以归纳成四条：vector和deque一旦触发扩容，所有迭代器、指针、引用全部失效；vector中间插入删除会让插入点之后的迭代器失效；map、set、list删除元素只影响被删那个的迭代器，其他仍然有效；reserve预分配能减少扩容次数，但不会让已失效的迭代器复活。范围for循环里修改容器大小同样危险，因为内部的迭代器是隐藏的。
4.3 函数模板、类模板与特化
模板的本质是编译期生成代码，所以类型推导规则必须清楚：模板参数T遇到const和引用时，T会推导成不带const的类型，而T&会保留const。这就是为什么转发函数要用T&&加std::forward，才能保住实参的左值右值属性。
#include <iostream> #include <type_traits> // 主模板：通用版本 template <typename T> struct TypeName { static const char* get() { return "unknown"; } }; // 全特化：为特定类型提供定制实现 template <> struct TypeName<int> { static const char* get() { return "int"; } }; // 偏特化：为指针类型提供定制实现 template <typename T> struct TypeName<T*> { static const char* get() { return "pointer"; } }; // 非类型模板参数：编译期常量，可用于固定大小数组 template <typename T, std::size_t N> struct FixedArray { T data[N]; constexpr std::size_t size() const { return N; } };函数模板只能全特化，不能偏特化；类模板两者都支持。模板的定义必须放在头文件里，因为实例化发生在使用处，编译器需要看到完整定义，这是「模板不能分离编译」的根因。模板报错信息又长又难读，从第一个错误往下看，通常第一个才是根因，后面都是级联。
4.4 std::thread、互斥量与条件变量
标准库的并发三件套是std::thread、std::mutex、std::condition_variable。要点集中在锁的管理方式和条件变量的等待条件上。
#include <condition_variable> #include <mutex> #include <queue> #include <thread> std::mutex mtx; std::condition_variable cv; std::queue<int> tasks; bool stop = false; void producer() { for (int i = 0; i < 100; ++i) { { std::lock_guard<std::mutex> lock(mtx); // RAII 加锁，出作用域自动解锁 tasks.push(i); } cv.notify_one(); // 通知放在解锁之后，减少唤醒后立刻阻塞 } { std::lock_guard<std::mutex> lock(mtx); stop = true; } cv.notify_all(); } void consumer() { while (true) { std::unique_lock<std::mutex> lock(mtx); // unique_lock 才能在 wait 里解锁 cv.wait(lock, [] { return !tasks.empty() || stop; }); // 谓词版 wait，天然处理虚假唤醒 if (tasks.empty() && stop) return; int v = tasks.front(); tasks.pop(); lock.unlock(); // 处理 v，耗时操作放在锁外 (void)v; } }lock_guard最轻量，只负责进出作用域加解锁；unique_lock灵活，可以手动解锁、可以配合条件变量。wait必须带谓词，因为存在虚假唤醒，不带谓词的版本会在队列为空时被唤醒然后取到垃圾数据。所有共享数据的读写都要在同一把锁的保护下，锁的粒度要尽量小，但也不能为了减小粒度把一次逻辑上的原子操作拆开。std::atomic适合计数器、标志位这类单一变量的场景，它不能替代锁去保护多字段的复合结构。
5. 易漏点排查：五个最容易翻车的 C++ 细节
前面的模块都过完，剩下的问题就集中在细节上。下面五条是梳理下来发现错误率最高的，共同特点是编译器不报错、运行时偶尔出错、出错位置离真正的问题很远。每条按「易漏点 → 为什么漏 → 怎么补」展开。
5.1 对象与语义层面的三处漏点
第一，拷贝构造写了，赋值运算符没写。为什么漏：很多人记住了「有指针就要写析构和拷贝构造」，却忘了赋值运算符也是默认生成的浅拷贝，一旦出现a = b就重复释放。怎么补：记住三法则的完整版是「析构、拷贝构造、拷贝赋值」三件套，或者直接用copy-and-swap一次性写对；更彻底的做法是把指针成员换成std::vector或智能指针，让默认版本重新变得正确。
第二，基类析构函数没有声明为 virtual。为什么漏：单看代码完全合法，编译也不报错，只有在「基类指针指向派生类对象并 delete」时才出问题，而日常写业务代码时往往用栈对象或智能指针，碰不到这条路径。怎么补：只要一个类打算被继承并且可能通过基类指针删除，析构就写virtual ~Base() = default;；如果是接口类，顺手把拷贝构造删掉，防止对象切片和误用。
第三，在构造函数或析构函数里调用虚函数。为什么漏：语法上完全允许，编译期也通过，只是运行时不走动态绑定，调用的是当前层次的版本。构造函数里想「先初始化基类再让派生类补一刀」是很自然的需求，于是这个坑特别容易踩。怎么补：把需要在派生类定制的初始化逻辑挪到工厂函数或者单独的init()里，构造阶段只做不依赖派生类的纯初始化。
5.2 内存与并发层面的两处漏点
第四，shared_ptr互相持有造成循环引用。为什么漏：shared_ptr给人的心理暗示是「用了它就不用管内存」，而循环引用在单次调用里没有任何症状，只有跑久了内存曲线缓慢上涨才能发现，属于典型的黑匣子问题。怎么补：明确所有权方向，父持有子的shared_ptr，子指回父用weak_ptr；使用前lock()提升成shared_ptr并判空。排查时可以在关键对象的析构里打日志，看谁一直没被释放。
第五，条件变量不带谓词，或者锁的粒度和逻辑不符。为什么漏：不带谓词的wait在绝大多数运行中是正常的，只有出现虚假唤醒或者notify早于wait时才出错，测试环境往往复现不了。怎么补：一律用带谓词的wait，谓词里写清楚「什么条件满足才能继续」；共享状态的所有读写都放在同一把锁内，notify放在解锁之后，避免唤醒的线程立刻又被阻塞。并发问题没法靠肉眼审查，只能靠约定加工具（线程检查工具、压力测试）兜底。
提示：这五条的共同解法是「让错误的写法写不出来」——用智能指针和容器替代裸资源管理，用
override和virtual让编译器替你检查，用带谓词的wait把语义写死。规则比记性可靠。
6. 复习清单：把资料用成一条可执行的路线
复习最怕的是「从头再看一遍」，因为看第二遍的边际收益极低。更有效的做法是按验收标准倒推：每一层都要有一个能证明「我真的会了」的动作，做不出来就停在这一层补，别往下赶。下面这张表可以当成主线进度表。
| 阶段 | 复习目标 | 验收标准 |
|---|---|---|
| 语法与表达式 | 类型宽度、隐式转换、运算符优先级 | 能徒手写出无符号下溢、浮点比较、位运算优先级的三个反例 |
| 类与对象 | 三法则/五法则、初始化列表、const 正确性 | 不查资料写出带深拷贝的类，并说明 copy-and-swap 解决了什么 |
| 继承与多态 | 虚函数表、虚析构、对象切片 | 能画出一个三层继承的对象内存布局，指出虚表指针位置 |
| 内存与指针 | 五区模型、RAII、智能指针 | 说出shared_ptr循环引用的成因，并用weak_ptr改对 |
| STL | 容器选择、迭代器失效 | 现场写出安全的erase循环，并解释为什么不能++it |
| 模板 | 推导规则、特化、不能分离编译 | 写出一个偏特化版本，说明定义为什么放头文件 |
| 并发 | 锁的 RAII、条件变量谓词 | 手写生产者消费者，不用查wait的参数顺序 |
| 工程实践 | 编译链接、调试、内存检查 | 能读懂链接错误，能用工具定位一次内存泄漏 |
工程实践这一段很多人跳过，实际是查漏补缺效率最高的地方。把多文件项目从源码编到可执行文件，至少要能说清预处理、编译、汇编、链接四步各做了什么，以及「未定义引用」和「重复定义」分别对应哪一步。
# 分步编译，观察每一步的产物，链接错误就出在最后一步 g++ -E main.cpp -o main.i # 预处理：展开宏和头文件 g++ -S main.i -o main.s # 编译：生成汇编 g++ -c main.s -o main.o # 汇编：生成目标文件 g++ main.o util.o -o app # 链接：合并目标文件与库 # 调试与检查：-g 保留符号，-fsanitize 在运行期抓内存和越界问题 g++ -g -O0 -fsanitize=address,undefined main.cpp -o app_debug # 头文件依赖和宏定义是链接错误的两大来源，先看这两处再改代码 g++ -I./include -DENABLE_LOG main.cpp -o app-I指定头文件搜索路径，-D在命令行定义宏，-g生成调试信息，-O0关掉优化以免变量被优化掉导致断点行为异常，-fsanitize=address能在越界或释放后使用时直接报出文件行号，比自己猜快得多。链接报「未定义引用」时优先查三件事：函数声明了但没定义、定义所在的源文件没参与编译、C 与 C++ 混编时忘了extern "C"。
时间分配上，语法和面向对象各占一成，内存与 STL 各占两成，现代特性与并发两成，工程实践和易错点回看占两成。每天留二十分钟做一件固定的事：不看资料，默写一小段代码——一个带深拷贝的类、一个安全的erase循环、一个生产者消费者——写完再对照，错的地方就是你真正的薄弱点。这比刷十集视频的定位精度高得多。
我自己的教训是曾经花了两周把课程从头看到尾，笔记记了厚厚一叠，结果第一次写多文件项目时卡在链接错误上整整一个下午，回头翻笔记发现那部分我压根没做笔记。从那以后我每次复习一个模块，都强制走一遍「写一段能跑的代码 → 故意写错一次 → 用工具把错误抓出来」的循环，写不出来就说明没学会，写得出来但改不对，说明只学会了表面。把这份 C++ 课程资源当成地图而不是课程表，按上面的清单一段段打勾，比按顺序刷完更有用。希望帮到你。
本文还有配套的精品资源，点击获取
