January 1, 2017

 1class Shape {
 2public:
 3    virtual void draw() = 0;    // 纯虚函数 抽象接口 派生类必须实现
 4    virtual ~Shape() = default; // 基类的析构函数应为虚函数 使用默认生成的函数实现
 5};
 6
 7// = 0         表示纯虚函数
 8// = default   表示使用编译器生成的默认实现
 9
10#include <iostream>
11#include <vector>
12
13struct Base {
14    std::vector<int> data{1, 2, 3};
15    ~Base() = default;  // 默认析构
16};
17
18int main() {
19    Base b;
20} 
21
22// 编译器会把 ~Base() = default; 变成类似：
23
24~Base() {
25    data.~vector();   // 自动调用 vector<int> 的析构函数
26}

析构函数应为虚函数，防止通过基类指针删除派生类对象时，派生类的析构函数不被调用，导致资源泄漏。

 1class Base {
 2public:
 3    ~Base() { std::cout << "Base dtor\n"; }
 4};
 5
 6class Derived : public Base {
 7public:
 8    ~Derived() { std::cout << "Derived dtor\n"; }
 9};
10
11Base* p = new Derived();
12delete p;  // 只会调用 Base::~Base()，不会调用 Derived::~Derived()

智能指针

std::unique_ptr

std::unique_ptr 是独占所有权的智能指针

独占所有权：同一时间只能有一个 unique_ptr 指向同一对象
不可拷贝（拷贝构造/赋值被禁用），但可移动
生命周期结束时会自动调用 delete 释放资源

 1#include <iostream>
 2#include <memory>
 3
 4int main() {
 5    std::unique_ptr<int> p1(new int(42));  // 管理一个int
 6    std::cout << *p1 << "\n";
 7
 8    // std::unique_ptr<int> p2 = p1; // ❌ 不允许拷贝
 9    std::unique_ptr<int> p2 = std::move(p1); // ✅ 允许移动
10    if (!p1) std::cout << "p1 is empty\n";
11}

什么推荐 make_unique 而不是 new？

异常安全：

c++ 17前，求值顺序未定义。先执行 new T，然后可能在传参时 g() 抛异常，结果 new 的结果还没交给unique_ptr，内存泄漏。
```
1f(std::unique_ptr<T>(new T), g());  
```
make_unique 内部是一条语句，new 出来的对象会立刻交给 unique_ptr，不会存在裸指针暂存的情况，资源会在异常传播时析构。
```
1f(std::make_unique<T>(), g());  
```
更简洁：不需要显式写 new。

避免重复类型：

1std::unique_ptr<MyClass> p1(new MyClass(1,2,3));   // 类型写了两遍
2auto p2 = std::make_unique<MyClass>(1,2,3);        // 类型只写一次

局部静态变量

静态初始化顺序问题

静态初始化顺序问题（Static Initialization Order Fiasco）。C++ 中全局/静态变量的初始化顺序：

同一个翻译单元（.cpp 文件），按照出现顺序初始化。
不同翻译单元，初始化顺序是未定义的。

 1// ShapeFactory.h
 2class ShapeFactory {
 3private:
 4    static std::unordered_map<std::string, Creator> registry;
 5public:
 6    static void registerShape(const std::string& name, Creator c) {
 7        registry[name] = c;
 8    }
 9};
10
11// ShapeFactory.cpp
12std::unordered_map<std::string, ShapeFactory::Creator> ShapeFactory::registry;

在另一个翻译单元有静态对象注册：

1// Circle.cpp
2struct CircleRegister {
3    CircleRegister() {
4        ShapeFactory::registerShape("circle", [](){ return std::make_unique<Circle>(); });
5    }
6};
7static CircleRegister cr;

如果 ShapeFactory::registry 还没初始化，registerShape 就会访问未定义内存，程序可能崩溃或行为异常。这个问题叫 Static Initialization Order Fiasco（静态初始化顺序地狱）。

使用 getRegistry() 的好处

1static std::unordered_map<std::string, Creator>& getRegistry() {
2    static std::unordered_map<std::string, Creator> registry;
3    return registry;
4}

局部静态变量在第一次调用时初始化，而不是编译时。这样无论 registerShape() 被哪个翻译单元的静态对象调用，registry 一定已经初始化。完全避免初始化顺序问题。

全局可见性问题（多个翻译单元）

也是初始化顺序问题的一种，在多个翻译单元中出现。假设你有三个 .cpp 文件：

1// Circle.cpp
2static struct { CircleRegister() { ShapeFactory::registerShape("circle", ...); } } cr;
3
4// Rectangle.cpp
5static struct { RectangleRegister() { ShapeFactory::registerShape("rectangle", ...); } } rr;
6
7// main.cpp
8int main() { ... }

静态成员变量 registry 是全局的，但初始化顺序不确定。如果 Circle.cpp 中的静态对象先调用 registerShape()，而 registry 还没初始化，就会访问未定义内存。局部静态函数延迟初始化，保证第一次使用时再创建 registry，完全解决跨翻译单元依赖问题。

线程安全问题

C++11前：静态成员变量初始化不是线程安全。多个线程同时访问静态成员变量的初始化，可能会导致竞态条件。
C++11后：函数内部静态变量初始化是线程安全的。

1void registerShapes() {
2    std::thread t1([](){ ShapeFactory::registerShape("circle", ...); });
3    std::thread t2([](){ ShapeFactory::registerShape("rectangle", ...); });
4    t1.join();
5    t2.join();
6}

如果 registry 是静态成员变量，C++11 之前可能出现访问冲突。使用局部静态变量，C++11+ 编译器保证初始化只执行一次，安全。

不同类型资源的风险等级

资源类型	OS清理	风险等级	主要问题
内存	✅ 完全清理	🟢 低	主要是逻辑问题
文件描述符	✅ 强制关闭	🟡 中	数据可能丢失
网络连接	✅ 强制断开	🟠 中高	服务端资源泄漏
文件锁	✅ 自动释放	🟡 中	锁文件可能残留
临时文件	❌ 不会删除	🔴 高	磁盘空间浪费
数据库连接	❌ 不会清理	🔴 高	连接池耗尽
共享内存	⚠️ 部分清理	🟠 中高	可能需要手动清理

explicit

explicit 关键字用于修饰构造函数，防止隐式类型转换。

 1// 没有explicit的类
 2class Observer {
 3public:
 4    Observer(const std::string& name) { 
 5        std::cout << "Observer: " << name << std::endl; 
 6    }
 7};
 8
 9// 有explicit的类  
10class File {
11public:
12    explicit File(const std::string& filename) { 
13        std::cout << "File: " << filename << std::endl; 
14    }
15};
16
17void process(Observer obs) {
18    std::cout << "Processing observer\n";
19}
20
21int main() {
22    // 1. 赋值 - 没有explicit时可以这样写
23    Observer obs = "Alice";        // ❌ 意外：看起来在赋值字符串
24    
25    // 2. 函数传参 - 没有explicit时可以这样写  
26    process("Bob");                // ❌ 意外：创建了临时Observer对象
27    
28    // 3. 文件例子 - 有explicit时必须明确
29    // File f = "test.txt";        // ❌ 编译错误！
30    File f("test.txt");            // ✅ 必须明确创建
31    
32    return 0;
33}

目录

1. 基础语法与关键字

2. 面向对象特性

3. 模板与泛型编程

4. 内存管理

5. 异常处理

6. 并发与多线程

7. 标准库关键组件

8. 编译时计算

9. 初始化演进

virtual