1
int x = 10, y = 20;
2

3
// 指针可以重新指向
4
int* p = &x;
5
p = &y;         // ✅ 现在指向 y
6

7
// 引用不能重新绑定
8
int& ref = x;
9
ref = y;        // ⚠️ 这不是重新绑定！这是把 y 的值赋给 x！
10
                // 执行后 x == 20，ref 仍然绑定 x
11

12
// 指针可以为空
13
int* null_p = nullptr;  // ✅ 合法
14

15
// 引用不能为空（标准不允许，虽然你可以强行做）
16
// int& null_ref = *nullptr;  // ❌ 未定义行为！

1
int x = 10, y = 20;
2

3
// 1. 指向 const 的指针（底层 const）
4
const int* p1 = &x;    // 不能通过 p1 修改 x
5
int const* p1b = &x;   // 与上面完全等价！（const 在 * 左边 → 修饰 int）
6
// *p1 = 20;           // ❌ 编译错误
7
p1 = &y;               // ✅ 可以指向别的对象
8

9
// 2. const 指针（顶层 const）
10
int* const p2 = &x;    // 指针本身不能改
11
*p2 = 20;              // ✅ 可以修改指向的值
12
// p2 = &y;            // ❌ 编译错误
13

14
// 3. 指向 const 的 const 指针（双重 const）
15
const int* const p3 = &x;
16
// *p3 = 20;           // ❌
17
// p3 = &y;            // ❌
18

19
// 4. const 引用
20
const int& cref = x;   // 不能通过 cref 修改 x
21
// cref = 20;          // ❌
22
// 但 x 本身可以改：
23
x = 20;                // ✅ cref 现在也是 20

1
std::weak_ptr<Widget> wp;
2

3
{
4
    auto sp = std::make_shared<Widget>();
5
    wp = sp;             // weak_ptr 不增加 strong_count
6

7
    // 使用 weak_ptr：必须先升级为 shared_ptr
8
    if (auto sp2 = wp.lock()) {
9
        // sp2 是有效的 shared_ptr，对象还活着
10
        sp2->doSomething();
11
    }
12

13
    wp.expired();        // false，对象还在
14
}
15
// sp 销毁 → strong_count = 0 → Widget 被析构
16

17
wp.expired();            // true，对象已死
18
if (auto sp3 = wp.lock()) {
19
    // 不会进来，lock() 返回空 shared_ptr
20
}

1
// === 陷阱 1：shared_ptr 从裸指针构造两次 ===
2
Widget* raw = new Widget();
3
std::shared_ptr<Widget> sp1(raw);
4
std::shared_ptr<Widget> sp2(raw);   // ❌ 两个独立的控制块！
5
// sp1 和 sp2 各自 strong_count = 1
6
// sp1 析构 → delete raw
7
// sp2 析构 → delete raw → 💥 Double Free！
8

9
// ✅ 正确做法：
10
auto sp1 = std::make_shared<Widget>();
11
auto sp2 = sp1;  // 共享同一个控制块
12

13
// === 陷阱 2：Lambda 捕获悬垂引用 ===
14
std::function<int()> createLambda() {
15
    int local = 42;
16
    return [&local]() { return local; };  // ❌ local 在返回后销毁！
17
    // 返回的 Lambda 持有一个悬垂引用
18
}
19
auto fn = createLambda();
20
fn();  // 💥 未定义行为！
21

22
// ✅ 正确做法：值捕获
23
std::function<int()> createLambdaFixed() {
24
    int local = 42;
25
    return [local]() { return local; };  // ✅ 拷贝了 local 的值
26
}
27

28
// === 陷阱 3：unique_ptr 尝试拷贝 ===
29
auto p1 = std::make_unique<Widget>();
30
// auto p2 = p1;              // ❌ 编译错误！禁止拷贝
31
auto p2 = std::move(p1);     // ✅ 移动
32

33
// === 陷阱 4：在容器中存 shared_ptr 导致意外延长生命周期 ===
34
std::vector<std::shared_ptr<Widget>> cache;
35
{
36
    auto w = std::make_shared<Widget>();
37
    cache.push_back(w);
38
}
39
// Widget 还没被销毁！因为 cache 中的 shared_ptr 还持有它
40
// 如果 cache 是一个缓存，应该用 weak_ptr
41
std::vector<std::weak_ptr<Widget>> weak_cache;  // ✅
42

43
// === 陷阱 5：悬垂指针三兄弟 ===
44
// 野指针（Wild Pointer）：未初始化的指针，指向随机地址
45
int* wild;          // 未初始化！值是栈上的垃圾
46
*wild = 42;         // 💥 写入随机地址 → 未定义行为
47

48
// 悬垂指针（Dangling Pointer）：指向已释放的内存
49
int* dangling = new int(42);
50
delete dangling;
51
*dangling = 100;    // 💥 Use-After-Free
52

53
// 空指针（Null Pointer）：显式指向"无"
54
int* null_ptr = nullptr;
55
*null_ptr = 42;     // 💥 段错误（但至少可以检查 if (!ptr)）
56

57
// ✅ 最佳实践：
58
// 1. 声明指针时立即初始化（= nullptr 或 = new ...）
59
// 2. delete 后立即置空：delete p; p = nullptr;
60
// 3. 优先用智能指针，让编译器帮你管
61

62
// === 陷阱 6：shared_ptr 的 this 指针陷阱 ===
63
class BadWidget {
64
public:
65
    std::shared_ptr<BadWidget> getShared() {
66
        // ❌ 从 this 裸指针构造 shared_ptr → 新的控制块 → Double Free！
67
        return std::shared_ptr<BadWidget>(this);
68
    }
69
};
70

71
auto sp = std::make_shared<BadWidget>();
72
auto sp2 = sp->getShared();  // 💥 两个控制块管理同一个对象！
73
// sp 和 sp2 析构时都会 delete this → Double Free
74

75
// ✅ 正确做法：继承 enable_shared_from_this（见 2.3.5）

1
// 游戏中，同一张纹理可能被多个 Sprite 使用
2
// 当所有使用者都释放后，纹理才应该被卸载
3

4
class TextureManager {
5
    std::unordered_map<std::string, std::weak_ptr<Texture>> _cache;
6

7
public:
8
    std::shared_ptr<Texture> load(const std::string& path) {
9
        // 1. 先检查缓存
10
        if (auto it = _cache.find(path); it != _cache.end()) {
11
            if (auto sp = it->second.lock()) {
12
                return sp;  // 缓存命中，返回已有纹理
13
            }
14
            // 纹理已被释放，缓存失效
15
            _cache.erase(it);
16
        }
17

18
        // 2. 缓存未命中，加载新纹理
19
        auto texture = std::make_shared<Texture>(path);
20
        _cache[path] = texture;  // 存 weak_ptr 到缓存
21
        return texture;
22
    }
23
};
24

25
// 使用：
26
TextureManager manager;
27
auto tex1 = manager.load("hero.png");   // 加载
28
auto tex2 = manager.load("hero.png");   // 缓存命中！tex1 和 tex2 共享同一张纹理
29
// tex1、tex2 都销毁后 → strong_count = 0 → 纹理自动卸载
30
// 下次 load("hero.png") 时重新加载

1
class Entity {
2
    std::string _name;
3
    // 追踪目标（可能随时被销毁）
4
    std::weak_ptr<Entity> _target;
5

6
public:
7
    Entity(std::string name) : _name(std::move(name)) {}
8

9
    void setTarget(std::shared_ptr<Entity> target) {
10
        _target = target;
11
    }
12

13
    void update() {
14
        if (auto target = _target.lock()) {
15
            // 目标还活着，追踪它
16
            std::cout << _name << " is chasing " << target->_name << "\n";
17
        } else {
18
            // 目标已死亡，停止追踪
19
            std::cout << _name << " lost target, idle\n";
20
            _target.reset();
21
        }
22
    }
23
};
24

25
// 使用：
26
auto player = std::make_shared<Entity>("Player");
27
auto enemy  = std::make_shared<Entity>("Enemy");
28
enemy->setTarget(player);
29

30
enemy->update();  // "Enemy is chasing Player"
31

32
player.reset();   // Player 被销毁
33
enemy->update();  // "Enemy lost target, idle" ← 安全地检测到目标死亡

1
class UIWidget {
2
    std::string _name;
3
    std::vector<std::unique_ptr<UIWidget>> _children;  // 独占子节点
4
    UIWidget* _parent = nullptr;                        // 裸指针：仅观察，不拥有
5

6
public:
7
    UIWidget(std::string name) : _name(std::move(name)) {}
8

9
    void addChild(std::unique_ptr<UIWidget> child) {
10
        child->_parent = this;
11
        _children.push_back(std::move(child));
12
    }
13

14
    // 父节点销毁时，所有子节点自动销毁（unique_ptr 析构链）
15
    // 子节点的 _parent 裸指针不影响父节点的生命周期
16
};
17

18
// 使用：
19
auto root = std::make_unique<UIWidget>("Root");
20
auto panel = std::make_unique<UIWidget>("Panel");
21
auto button = std::make_unique<UIWidget>("Button");
22

23
panel->addChild(std::move(button));
24
root->addChild(std::move(panel));
25

26
// root 销毁 → Panel 自动销毁 → Button 自动销毁
27
// 整个 UI 树自动清理，无需手动 delete

1
class EventSystem {
2
    std::vector<std::pair<
3
        std::weak_ptr<void>,           // 观察者的生命周期
4
        std::function<void()>           // 回调函数
5
    >> _listeners;
6

7
public:
8
    // 注册监听器时同时绑定生命周期
9
    template <typename T>
10
    void subscribe(std::shared_ptr<T> owner, std::function<void()> callback) {
11
        _listeners.emplace_back(owner, std::move(callback));
12
    }
13

14
    void fire() {
15
        // 清理已死亡的监听器，只调用存活的
16
        _listeners.erase(
17
            std::remove_if(_listeners.begin(), _listeners.end(),
18
                [](auto& pair) { return pair.first.expired(); }),
19
            _listeners.end()
20
        );
21

22
        for (auto& [wp, cb] : _listeners) {
23
            if (!wp.expired()) {
24
                cb();
25
            }
26
        }
27
    }
28
};
29

30
// 使用：
31
EventSystem events;
32
{
33
    auto npc = std::make_shared<Entity>("NPC");
34
    events.subscribe(npc, []() { std::cout << "NPC reacts!\n"; });
35
    events.fire();  // "NPC reacts!"
36
}
37
// npc 已销毁
38
events.fire();      // 不会调用回调，因为 weak_ptr 已过期 ✅

1
// OpenGL 纹理的 RAII 封装
2
struct GLTextureDeleter {
3
    void operator()(GLuint* id) const {
4
        if (id && *id != 0) {
5
            glDeleteTextures(1, id);
6
            std::cout << "GPU Texture " << *id << " released\n";
7
        }
8
        delete id;
9
    }
10
};
11

12
// unique_ptr + 自定义 deleter
13
std::unique_ptr<GLuint, GLTextureDeleter> createTexture() {
14
    auto id = std::make_unique<GLuint>(0);
15
    glGenTextures(1, id.get());
16
    glBindTexture(GL_TEXTURE_2D, *id);
17
    // ... 设置纹理参数、上传数据 ...
18
    return std::unique_ptr<GLuint, GLTextureDeleter>(id.release());
19
}
20

21
// 更简洁的写法：用 Lambda 作为 deleter
22
auto createBuffer() {
23
    GLuint vbo = 0;
24
    glGenBuffers(1, &vbo);
25
    // ... 上传顶点数据 ...
26

27
    // Lambda deleter（注意：sizeof 会增大！）
28
    auto deleter = [](GLuint* id) {
29
        glDeleteBuffers(1, id);
30
        delete id;
31
    };
32
    return std::unique_ptr<GLuint, decltype(deleter)>(
33
        new GLuint(vbo), deleter
34
    );
35
}
36

37
// 使用：
38
{
39
    auto texture = createTexture();
40
    auto buffer  = createBuffer();
41
    // ... 渲染 ...
42
}
43
// 作用域结束 → 自动调用 glDeleteTextures / glDeleteBuffers
44
// 即使中间抛异常，GPU 资源也不会泄漏 ✅

1
// 通用 GPU Handle（生产代码中更常见的写法）
2
template <typename CreateFunc, typename DestroyFunc>
3
class GPUHandle {
4
    GLuint _id = 0;
5
    DestroyFunc _destroy;
6

7
public:
8
    GPUHandle(CreateFunc create, DestroyFunc destroy)
9
        : _destroy(std::move(destroy)) {
10
        create(&_id);
11
    }
12

13
    ~GPUHandle() {
14
        if (_id != 0) _destroy(_id);
15
    }
16

17
    // 禁止拷贝，允许移动
18
    GPUHandle(const GPUHandle&) = delete;
19
    GPUHandle& operator=(const GPUHandle&) = delete;
20

21
    GPUHandle(GPUHandle&& other) noexcept : _id(other._id), _destroy(std::move(other._destroy)) {
22
        other._id = 0;
23
    }
24

25
    GLuint id() const { return _id; }
26
    operator GLuint() const { return _id; }
27
};
28

29
// 使用：
30
auto vao = GPUHandle(
31
    [](GLuint* id) { glGenVertexArrays(1, id); },
32
    [](GLuint id)  { glDeleteVertexArrays(1, &id); }
33
);
34

35
auto shader = GPUHandle(
36
    [](GLuint* id) { *id = glCreateProgram(); },
37
    [](GLuint id)  { glDeleteProgram(id); }
38
);
39
// 离开作用域自动清理 ✅