1
// 通用的固定大小数组
2
template <typename T, size_t N>
3
class Array {
4
    T _data[N];
5

6
public:
7
    T& operator[](size_t i) { return _data[i]; }
8
    const T& operator[](size_t i) const { return _data[i]; }
9
    constexpr size_t size() const { return N; }
10

11
    T* begin() { return _data; }
12
    T* end()   { return _data + N; }
13
};
14

15
Array<int, 10> arr;    // T=int, N=10
16
Array<float, 3> vec;   // T=float, N=3

1
#include <type_traits>
2

3
// 编译期查询类型属性
4
static_assert(std::is_integral_v<int>);           // true
5
static_assert(std::is_floating_point_v<double>);   // true
6
static_assert(std::is_pointer_v<int*>);            // true
7
static_assert(std::is_same_v<int, int32_t>);       // true（通常）
8

9
// 编译期类型变换
10
using T1 = std::remove_const_t<const int>;         // int
11
using T2 = std::remove_reference_t<int&>;          // int
12
using T3 = std::add_pointer_t<int>;                // int*
13
using T4 = std::decay_t<const int&>;               // int（去引用 + 去const）
14

15
// 条件类型选择
16
using T5 = std::conditional_t<sizeof(int) == 4,
17
    int32_t, int64_t>;  // 根据 int 大小选择类型
18

19
// 实际应用：安全的数值转换
20
template <typename To, typename From>
21
To safe_cast(From value) {
22
    static_assert(std::is_arithmetic_v<From> && std::is_arithmetic_v<To>,
23
                  "safe_cast only works with arithmetic types");
24

25
    if constexpr (std::is_same_v<To, From>) {
26
        return value;  // 同类型，直接返回
27
    } else {
28
        // 检查范围
29
        if (value > static_cast<From>(std::numeric_limits<To>::max()) ||
30
            value < static_cast<From>(std::numeric_limits<To>::lowest())) {
31
            throw std::overflow_error("Value out of range");
32
        }
33
        return static_cast<To>(value);
34
    }
35
}

1
// === 陷阱 1：dependent name 需要 typename ===
2
template <typename T>
3
void foo() {
4
    // T::value_type 可能是类型也可能是静态成员
5
    // typename T::value_type x;   // ✅ 告诉编译器这是类型
6
    // T::value_type x;            // ❌ 编译器默认当作值，报错
7
}
8

9
// === 陷阱 2：模板方法的两阶段查找 ===
10
template <typename T>
11
class Base {
12
public:
13
    void base_func() {}
14
};
15

16
template <typename T>
17
class Derived : public Base<T> {
18
public:
19
    void derived_func() {
20
        // base_func();             // ❌ 可能找不到！因为 Base<T> 是依赖类型
21
        this->base_func();          // ✅ 用 this-> 明确
22
        Base<T>::base_func();       // ✅ 或显式指定
23
    }
24
};
25

26
// === 陷阱 3：auto 推导类型陷阱 ===
27
auto x1 = 42;          // int
28
auto x2 = {42};         // std::initializer_list<int>！不是 int！
29
auto x3{42};            // C++17 起是 int（C++11/14 是 initializer_list<int>）
30

31
// === 陷阱 4：decltype vs auto ===
32
int x = 42;
33
int& ref = x;
34
auto a = ref;            // int（auto 去掉引用）
35
decltype(ref) b = x;     // int&（decltype 保留引用）
36
decltype(auto) c = ref;  // int&（decltype(auto) = decltype(expr)）

1
// 游戏引擎中很多资源用 ID (uint32_t) 引用
2
// 问题：TextureID 和 MeshID 都是 uint32_t，容易混用
3

4
// 模板方案：编译期区分不同类型的 Handle
5
template <typename Tag>
6
class Handle {
7
    uint32_t _id;
8

9
public:
10
    explicit Handle(uint32_t id = 0) : _id(id) {}
11
    uint32_t id() const { return _id; }
12
    bool valid() const { return _id != 0; }
13

14
    bool operator==(Handle other) const { return _id == other._id; }
15
    bool operator!=(Handle other) const { return _id != other._id; }
16

17
    // 支持作为 unordered_map 的 key
18
    struct Hash {
19
        size_t operator()(Handle h) const { return std::hash<uint32_t>{}(h._id); }
20
    };
21
};
22

23
// 用空 struct 做 Tag，零开销
24
struct TextureTag {};
25
struct MeshTag {};
26
struct ShaderTag {};
27

28
using TextureHandle = Handle<TextureTag>;
29
using MeshHandle    = Handle<MeshTag>;
30
using ShaderHandle  = Handle<ShaderTag>;
31

32
// 使用：
33
TextureHandle tex(1);
34
MeshHandle mesh(2);
35

36
// tex == mesh;            // ❌ 编译错误！类型不同
37
// loadMesh(tex);          // ❌ 编译错误！类型不匹配
38
loadMesh(mesh);            // ✅ 类型正确
39

40
// 零运行时开销：sizeof(TextureHandle) == sizeof(uint32_t) == 4

1
// 类型安全的对象池（结合 Ch1 的 Pool Allocator）
2
template <typename T, size_t PoolSize = 1024>
3
class ObjectPool {
4
    union Slot {
5
        T object;
6
        Slot* next;
7
        Slot() {}   // union 默认构造
8
        ~Slot() {}
9
    };
10

11
    std::array<Slot, PoolSize> _pool;
12
    Slot* _free_list = nullptr;
13

14
public:
15
    ObjectPool() {
16
        for (size_t i = 0; i < PoolSize - 1; ++i)
17
            _pool[i].next = &_pool[i + 1];
18
        _pool[PoolSize - 1].next = nullptr;
19
        _free_list = &_pool[0];
20
    }
21

22
    template <typename... Args>
23
    T* create(Args&&... args) {
24
        if (!_free_list) return nullptr;
25
        Slot* slot = _free_list;
26
        _free_list = _free_list->next;
27
        // 完美转发 + placement new（交汇 Ch1 和 Ch4）
28
        return new (&slot->object) T(std::forward<Args>(args)...);
29
    }
30

31
    void destroy(T* obj) {
32
        obj->~T();
33
        Slot* slot = reinterpret_cast<Slot*>(obj);
34
        slot->next = _free_list;
35
        _free_list = slot;
36
    }
37
};
38

39
// 使用：
40
struct Bullet {
41
    float x, y, speed;
42
    Bullet(float px, float py, float s) : x(px), y(py), speed(s) {}
43
};
44

45
ObjectPool<Bullet, 4096> bullet_pool;
46
Bullet* b = bullet_pool.create(0.f, 0.f, 100.f);  // 原地构造
47
// ... 使用 ...
48
bullet_pool.destroy(b);  // 手动析构 + 回收

1
// 用变参模板实现灵活的组件添加
2
class Entity {
3
    uint32_t _id;
4
    std::unordered_map<size_t, std::any> _components;
5

6
public:
7
    Entity(uint32_t id) : _id(id) {}
8

9
    // 添加单个组件
10
    template <typename T, typename... Args>
11
    T& addComponent(Args&&... args) {
12
        auto typeId = typeid(T).hash_code();
13
        _components[typeId] = T(std::forward<Args>(args)...);
14
        return std::any_cast<T&>(_components[typeId]);
15
    }
16

17
    // 获取组件
18
    template <typename T>
19
    T* getComponent() {
20
        auto it = _components.find(typeid(T).hash_code());
21
        if (it == _components.end()) return nullptr;
22
        return std::any_cast<T>(&it->second);
23
    }
24

25
    // 检查是否有某些组件（变参模板）
26
    template <typename... Components>
27
    bool hasComponents() const {
28
        return ((_components.count(typeid(Components).hash_code()) > 0) && ...);
29
        // C++17 折叠表达式：所有组件都存在才返回 true
30
    }
31
};
32

33
// 使用：
34
Entity player(1);
35
player.addComponent<Position>(0.f, 0.f, 0.f);
36
player.addComponent<Velocity>(1.f, 0.f, 0.f);
37
player.addComponent<Health>(100.f, 100.f);
38

39
if (player.hasComponents<Position, Velocity>()) {
40
    auto* pos = player.getComponent<Position>();
41
    auto* vel = player.getComponent<Velocity>();
42
    // 移动系统
43
}

1
// 用 type_traits 实现自动序列化
2
template <typename T>
3
void serialize(std::ostream& os, const T& value) {
4
    if constexpr (std::is_arithmetic_v<T>) {
5
        // 数值类型：直接写入二进制
6
        os.write(reinterpret_cast<const char*>(&value), sizeof(T));
7
    } else if constexpr (std::is_same_v<T, std::string>) {
8
        // 字符串：先写长度，再写内容
9
        uint32_t len = static_cast<uint32_t>(value.size());
10
        os.write(reinterpret_cast<const char*>(&len), sizeof(len));
11
        os.write(value.data(), len);
12
    } else if constexpr (requires { value.serialize(os); }) {
13
        // 有 serialize 方法的类型：调用自己的序列化
14
        value.serialize(os);
15
    } else {
16
        static_assert(false, "Type is not serializable");
17
    }
18
}
19

20
// 变参模板：批量序列化
21
template <typename... Args>
22
void serializeAll(std::ostream& os, const Args&... args) {
23
    (serialize(os, args), ...);  // 折叠表达式
24
}
25

26
// 使用：
27
std::ofstream file("save.dat", std::ios::binary);
28
serializeAll(file, player.hp, player.x, player.y, player.name);