1
// emplace_back 的简化原理：
2
template <typename T>
3
class SimpleVector {
4
    T* _data;
5
    size_t _size, _capacity;
6

7
public:
8
    template <typename... Args>
9
    void emplace_back(Args&&... args) {
10
        if (_size == _capacity) grow();
11

12
        // 不是 _data[_size] = T(args...)（会多一次拷贝/移动）
13
        // 而是直接在目标位置原地构造：
14
        new (_data + _size) T(std::forward<Args>(args)...);
15
        ++_size;
16
    }
17

18
    void pop_back() {
19
        --_size;
20
        (_data + _size)->~T();  // 手动调用析构（不释放内存）
21
    }
22
};

1
// === 场景 1：忘记 delete ===
2
void leak1() {
3
    int* p = new int[1000];
4
    // ... 一些操作 ...
5
    return;  // ❌ 忘记 delete[]，泄漏 4000 字节
6
}
7

8
// === 场景 2：异常导致跳过 delete ===
9
void leak2() {
10
    int* p = new int[1000];
11
    riskyOperation();   // 如果这里抛异常...
12
    delete[] p;         // ❌ 这行永远不会执行！
13
}
14
// ✅ 解决方案：用智能指针（Ch2 详细讲）
15
void no_leak() {
16
    auto p = std::make_unique<int[]>(1000);
17
    riskyOperation();   // 即使抛异常，unique_ptr 析构时自动释放
18
}
19

20
// === 场景 3：容器中的裸指针 ===
21
void leak3() {
22
    std::vector<MyClass*> objects;
23
    objects.push_back(new MyClass());
24
    objects.push_back(new MyClass());
25
    objects.clear();    // ❌ 只清空了指针，对象还在堆上！
26
}
27
// ✅ 解决方案：
28
void no_leak3() {
29
    std::vector<std::unique_ptr<MyClass>> objects;
30
    objects.push_back(std::make_unique<MyClass>());
31
    objects.clear();    // ✅ unique_ptr 自动 delete 对象
32
}

1
// === 返回局部变量的引用 ===
2
int& dangling_ref() {
3
    int local = 42;
4
    return local;       // ❌ local 在函数返回后被销毁！
5
}                       // 返回的引用指向已销毁的栈内存
6

7
// === 返回局部变量的地址 ===
8
int* dangling_ptr() {
9
    int local = 42;
10
    return &local;      // ❌ 同上
11
}
12

13
// === Use-After-Free ===
14
void use_after_free() {
15
    int* p = new int(42);
16
    delete p;
17
    *p = 100;           // ❌ 未定义行为！p 指向的内存已释放
18
}
19

20
// === Delete 后不置空 ===
21
void double_delete() {
22
    int* p = new int(42);
23
    delete p;
24
    // ... 很多行代码 ...
25
    delete p;           // ❌ 二次释放！未定义行为
26

27
    // ✅ 好习惯：delete 后置空
28
    // delete p;
29
    // p = nullptr;
30
    // delete nullptr 是安全的（什么都不做）
31
}

1
#include <cstddef>
2
#include <cstdint>
3
#include <cassert>
4
#include <new>
5

6
// 固定大小对象池
7
// 核心思想：把空闲块串成链表（Free List），分配 = 链表头部弹出，释放 = 链表头部压入
8
template <typename T, std::size_t PoolSize = 1024>
9
class PoolAllocator {
10
    // 空闲块节点（复用对象的内存空间存储 next 指针）
11
    union Slot {
12
        T object;
13
        Slot* next;
14

15
        Slot() {}   // 不初始化
16
        ~Slot() {}
17
    };
18

19
    Slot _pool[PoolSize];  // 预分配的内存块
20
    Slot* _free_list;      // 空闲链表头
21
    std::size_t _used;     // 已使用的数量
22

23
public:
24
    PoolAllocator() : _free_list(nullptr), _used(0) {
25
        // 初始化空闲链表：所有 slot 串起来
26
        for (std::size_t i = 0; i < PoolSize; ++i) {
27
            _pool[i].next = _free_list;
28
            _free_list = &_pool[i];
29
        }
30
    }
31

32
    // 分配一个对象（从空闲链表头部弹出）
33
    template <typename... Args>
34
    T* allocate(Args&&... args) {
35
        if (!_free_list) {
36
            throw std::bad_alloc();  // 池满了
37
        }
38

39
        Slot* slot = _free_list;
40
        _free_list = _free_list->next;
41
        ++_used;
42

43
        // 在这块内存上 placement new 构造对象
44
        return new (&slot->object) T(std::forward<Args>(args)...);
45
    }
46

47
    // 释放一个对象（调用析构，然后放回空闲链表头部）
48
    void deallocate(T* obj) {
49
        obj->~T();  // 手动调用析构函数
50

51
        Slot* slot = reinterpret_cast<Slot*>(obj);
52
        slot->next = _free_list;
53
        _free_list = slot;
54
        --_used;
55
    }
56

57
    std::size_t used() const { return _used; }
58
    std::size_t available() const { return PoolSize - _used; }
59
};

1
struct Bullet {
2
    float x, y, z;
3
    float speed;
4
    float damage;
5
    bool active;
6

7
    Bullet(float px, float py, float pz, float spd, float dmg)
8
        : x(px), y(py), z(pz), speed(spd), damage(dmg), active(true) {}
9
};
10

11
// 预分配 4096 个子弹的内存
12
PoolAllocator<Bullet, 4096> bullet_pool;
13

14
void SpawnBullet(float x, float y, float z) {
15
    Bullet* b = bullet_pool.allocate(x, y, z, 100.0f, 25.0f);
16
    // ... 添加到活跃子弹列表 ...
17
}
18

19
void DestroyBullet(Bullet* b) {
20
    // ... 从活跃列表移除 ...
21
    bullet_pool.deallocate(b);
22
}

1
class FrameAllocator {
2
    uint8_t* _buffer;       // 预分配的大内存块
3
    std::size_t _capacity;  // 总容量
4
    std::size_t _offset;    // 当前分配位置
5

6
public:
7
    explicit FrameAllocator(std::size_t capacity)
8
        : _capacity(capacity), _offset(0) {
9
        _buffer = static_cast<uint8_t*>(std::malloc(capacity));
10
    }
11

12
    ~FrameAllocator() {
13
        std::free(_buffer);
14
    }
15

16
    // 分配 N 字节（带对齐）
17
    void* allocate(std::size_t size, std::size_t alignment = alignof(std::max_align_t)) {
18
        // 对齐调整
19
        std::size_t aligned_offset = (_offset + alignment - 1) & ~(alignment - 1);
20

21
        if (aligned_offset + size > _capacity) {
22
            return nullptr;  // 本帧内存用尽（应该增大容量）
23
        }
24

25
        void* ptr = _buffer + aligned_offset;
26
        _offset = aligned_offset + size;
27
        return ptr;
28
    }
29

30
    // 类型安全的分配 + 构造
31
    template <typename T, typename... Args>
32
    T* create(Args&&... args) {
33
        void* mem = allocate(sizeof(T), alignof(T));
34
        if (!mem) return nullptr;
35
        return new (mem) T(std::forward<Args>(args)...);
36
    }
37

38
    // 帧结束：一次性全部释放！
39
    void reset() {
40
        _offset = 0;  // 就这么简单。不需要逐个析构（限制：只用于 POD 类型）
41
    }
42

43
    std::size_t used() const { return _offset; }
44
    std::size_t remaining() const { return _capacity - _offset; }
45
};
46

47
// === 使用示例 ===
48
FrameAllocator frame_alloc(1024 * 1024);  // 1MB 帧内存
49

50
void GameLoop() {
51
    while (running) {
52
        // --- 帧开始 ---
53
        frame_alloc.reset();  // 上一帧的临时数据全部释放
54

55
        // 本帧的临时数据直接从 frame_alloc 分配
56
        auto* collision_results = frame_alloc.create<CollisionResult>();
57
        auto* render_commands = static_cast<RenderCmd*>(
58
            frame_alloc.allocate(sizeof(RenderCmd) * 256)
59
        );
60

61
        Update();
62
        Render();
63
        // --- 帧结束 ---
64
        // 不需要逐个 delete！reset() 下一帧统一清理
65
    }
66
}

1
#include <immintrin.h>  // SSE/AVX 头文件
2

3
// 一个 SIMD 友好的 3D 向量（对齐到 16 字节，方便 SSE）
4
struct alignas(16) Vec4 {
5
    float x, y, z, w;  // 4 × 4B = 16B，正好一个 SSE 寄存器
6
};
7
static_assert(sizeof(Vec4) == 16);
8
static_assert(alignof(Vec4) == 16);
9

10
// === 标量版本：逐个计算 ===
11
void addPositions_scalar(Vec4* dst, const Vec4* a, const Vec4* b, int count) {
12
    for (int i = 0; i < count; ++i) {
13
        dst[i].x = a[i].x + b[i].x;
14
        dst[i].y = a[i].y + b[i].y;
15
        dst[i].z = a[i].z + b[i].z;
16
        dst[i].w = a[i].w + b[i].w;
17
    }
18
}
19

20
// === SIMD 版本：一次处理 4 个 float ===
21
void addPositions_simd(Vec4* dst, const Vec4* a, const Vec4* b, int count) {
22
    for (int i = 0; i < count; ++i) {
23
        __m128 va = _mm_load_ps(reinterpret_cast<const float*>(&a[i]));   // 要求 16 字节对齐！
24
        __m128 vb = _mm_load_ps(reinterpret_cast<const float*>(&b[i]));
25
        __m128 vc = _mm_add_ps(va, vb);   // 一条指令完成 4 个加法
26
        _mm_store_ps(reinterpret_cast<float*>(&dst[i]), vc);              // 存回
27
    }
28
}
29

30
// 如果数据未对齐到 16 字节：
31
// _mm_load_ps → 💥 段错误（或用 _mm_loadu_ps 降级到未对齐加载，但更慢）

1
// === AoS (Array of Structures) —— 传统面向对象 ===
2
struct Entity_AoS {
3
    float x, y, z;       // 位置
4
    float vx, vy, vz;    // 速度
5
    float health;         // 血量
6
    int   sprite_id;      // 贴图 ID
7
    bool  active;         // 是否激活
8
    // ... 可能还有很多字段
9
};
10
std::vector<Entity_AoS> entities(10000);
11

12
// 更新位置：遍历所有实体
13
for (auto& e : entities) {
14
    e.x += e.vx * dt;
15
    e.y += e.vy * dt;
16
    e.z += e.vz * dt;
17
}
18
// 问题：每次迭代加载一个 Entity（~40+ 字节）到缓存
19
// 但我们只用了其中 24 字节（x,y,z,vx,vy,vz）
20
// health, sprite_id, active 白白占用了缓存行！
21

22

23
// === SoA (Structure of Arrays) —— 数据驱动 ===
24
struct Entities_SoA {
25
    std::vector<float> x,  y,  z;    // 所有实体的 x 坐标连续存放
26
    std::vector<float> vx, vy, vz;
27
    std::vector<float> health;
28
    std::vector<int>   sprite_id;
29
    std::vector<bool>  active;
30
};
31
Entities_SoA entities;  // 每个 vector 初始化 10000 个元素
32

33
// 更新位置：
34
for (int i = 0; i < n; ++i) {
35
    entities.x[i] += entities.vx[i] * dt;
36
}
37
for (int i = 0; i < n; ++i) {
38
    entities.y[i] += entities.vy[i] * dt;
39
}
40
for (int i = 0; i < n; ++i) {
41
    entities.z[i] += entities.vz[i] * dt;
42
}
43
// 优势：x 数组是连续的 float，一条缓存行装 16 个 float
44
// 不浪费缓存空间，且编译器更容易做 SIMD 自动向量化