1
class AudioManager {
2
public:
3
    // C++11 保证：static 局部变量初始化是线程安全的
4
    static AudioManager& GetInstance() {
5
        static AudioManager instance;
6
        return instance;
7
    }
8

9
    void PlaySound(const std::string& name) {
10
        // ...
11
    }
12

13
    // 禁止拷贝和赋值
14
    AudioManager(const AudioManager&) = delete;
15
    AudioManager& operator=(const AudioManager&) = delete;
16

17
private:
18
    AudioManager() {
19
        // 初始化音频引擎
20
    }
21
    ~AudioManager() {
22
        // 清理音频引擎
23
    }
24
};
25

26
// 使用
27
AudioManager::GetInstance().PlaySound("explosion.wav");

1
// ⚠️ 仅供面试展示——实际项目请用 Meyers' Singleton
2

3
class GameConfig {
4
public:
5
    static GameConfig* GetInstance() {
6
        // 第一次检查：大多数时候 instance 已存在，避免加锁开销
7
        if (instance == nullptr) {
8
            std::lock_guard<std::mutex> lock(mutex);
9
            // 第二次检查：防止在等锁期间，另一个线程已经创建了实例
10
            if (instance == nullptr) {
11
                instance = new GameConfig();
12
            }
13
        }
14
        return instance;
15
    }
16

17
private:
18
    static GameConfig* instance;
19
    static std::mutex mutex;
20

21
    GameConfig() = default;
22
};
23

24
GameConfig* GameConfig::instance = nullptr;
25
std::mutex GameConfig::mutex;

1
// 带优先级的单例管理器
2
class SingletonManager {
3
public:
4
    template<typename T>
5
    static void Register(int priority) {
6
        auto& entry = GetEntries().emplace_back();
7
        entry.creator = [] { return static_cast<void*>(new T()); };
8
        entry.destroyer = [](void* p) { delete static_cast<T*>(p); };
9
        entry.priority = priority;
10
    }
11

12
    static void Shutdown() {
13
        auto& entries = GetEntries();
14
        // 按优先级逆序析构（高优先级后析构）
15
        std::sort(entries.begin(), entries.end(),
16
            [](auto& a, auto& b) { return a.priority > b.priority; });
17

18
        for (auto& entry : entries) {
19
            entry.destroyer(entry.instance);
20
        }
21
    }
22

23
private:
24
    struct Entry {
25
        void* instance = nullptr;
26
        std::function<void*()> creator;
27
        std::function<void(void*)> destroyer;
28
        int priority = 0;
29
    };
30
    static std::vector<Entry>& GetEntries() {
31
        static std::vector<Entry> entries;
32
        return entries;
33
    }
34
};
35

36
// 使用
37
// 程序启动时
38
SingletonManager::Register<AudioManager>(100);    // 优先级 100
39
SingletonManager::Register<ResourceManager>(50);   // 优先级 50，后析构
40

41
// 程序关闭时
42
SingletonManager::Shutdown();
43
// ResourceManager 先析构 → AudioManager 后析构

1
// 典型的游戏 Manager 单例模式
2
class GameManager {
3
public:
4
    static GameManager& Get() {
5
        static GameManager instance;
6
        return instance;
7
    }
8

9
    // 游戏流程控制
10
    void StartGame();
11
    void PauseGame();
12
    void ResumeGame();
13
    void QuitToMainMenu();
14

15
    // 全局状态查询
16
    bool IsPaused() const { return isPaused; }
17
    float GetGameTime() const { return gameTime; }
18

19
    // 场景加载——内部使用工厂模式（见下节）
20
    void LoadScene(const std::string& sceneName);
21
    Scene* GetCurrentScene() const { return currentScene; }
22

23
private:
24
    GameManager() = default;
25
    bool isPaused = false;
26
    float gameTime = 0.0f;
27
    Scene* currentScene = nullptr;
28
};
29

30
// 游戏中随处可用
31
void Enemy::Die() {
32
    GameManager::Get().GetCurrentScene()->SpawnPickup(position);
33
    // 不需要传 GameManager 指针——它是真正的"全局基础设施"
34
}

1
// 简单工厂——用一个函数 + 配置表替代 switch
2
class EnemyFactory {
3
public:
4
    static std::unique_ptr<Enemy> Create(int enemyId) {
5
        auto& config = ConfigManager::Get().GetEnemyConfig(enemyId);
6

7
        auto enemy = std::make_unique<Enemy>();
8
        enemy->SetModel(config.modelPath);
9
        enemy->SetHealth(config.health);
10
        enemy->SetSkills(config.skillIds);
11
        // 所有敌人都是同一个 Enemy 类，只是数据不同
12

13
        return enemy;
14
    }
15
};
16

17
// 使用
18
auto goblin = EnemyFactory::Create(1);   // 哥布林
19
auto orc = EnemyFactory::Create(2);      // 兽人

1
// ============ 步骤一：注册机制 ============
2

3
// 每个敌人类型注册自己的工厂函数
4
class EnemyRegistry {
5
public:
6
    using FactoryFunc = std::function<std::unique_ptr<Enemy>(const EnemyConfig&)>;
7

8
    static void Register(const std::string& typeName, FactoryFunc factory) {
9
        GetFactories()[typeName] = std::move(factory);
10
    }
11

12
    static std::unique_ptr<Enemy> Create(const std::string& typeName,
13
                                          const EnemyConfig& config) {
14
        auto it = GetFactories().find(typeName);
15
        if (it != GetFactories().end()) {
16
            return it->second(config);
17
        }
18
        return nullptr;
19
    }
20

21
private:
22
    static std::unordered_map<std::string, FactoryFunc>& GetFactories() {
23
        static std::unordered_map<std::string, FactoryFunc> factories;
24
        return factories;
25
    }
26
};
27

28
// ============ 步骤二：具体敌人注册自己 ============
29

30
class Goblin : public Enemy {
31
public:
32
    // 静态注册——程序启动时自动执行
33
    static bool registered;
34
};
35

36
bool Goblin::registered = []() {
37
    EnemyRegistry::Register("goblin", [](const EnemyConfig& cfg) {
38
        auto goblin = std::make_unique<Goblin>();
39
        goblin->Init(cfg);
40
        return goblin;
41
    });
42
    return true;
43
}();
44

45
// 其他敌人类同样注册
46
class Orc : public Enemy {
47
public:
48
    static bool registered;
49
};
50
bool Orc::registered = []() {
51
    EnemyRegistry::Register("orc", [](const EnemyConfig& cfg) {
52
        auto orc = std::make_unique<Orc>();
53
        orc->Init(cfg);
54
        return orc;
55
    });
56
    return true;
57
}();
58

59
// ============ 步骤三：配置表驱动创建 ============
60
// 策划的配置表：
61
// | ID | type    | health | model       |
62
// | 1  | "goblin"| 100    | goblin.fbx  |
63
// | 2  | "orc"   | 300    | orc.fbx     |
64

65
void SpawnEnemy(int configId) {
66
    auto& row = ConfigManager::Get().GetEnemyRow(configId);
67
    auto enemy = EnemyRegistry::Create(row.typeName, row);
68
    if (enemy) {
69
        currentScene->AddEnemy(std::move(enemy));
70
    }
71
}
72

73
// 策划加了第 21 种敌人？写一个新类，注册一下，配置表填一行。
74
// SpawnEnemy() 不需要改。OCP 达成。

1
// 完整的配置驱动敌人系统
2

3
// 1. 配置表结构
4
struct EnemyConfig {
5
    int id;
6
    std::string typeName;   // 对应注册的工厂 key
7
    std::string modelPath;
8
    float health;
9
    float attackPower;
10
    std::vector<int> skillIds;
11
    std::unordered_map<std::string, float> customParams;  // 扩展字段
12
};
13

14
// 2. 抽象 Enemy 基类
15
class Enemy {
16
public:
17
    virtual void Init(const EnemyConfig& config) {
18
        health = config.health;
19
        maxHealth = config.health;
20
        attackPower = config.attackPower;
21
        LoadModel(config.modelPath);
22
    }
23

24
    virtual void UpdateAI(float dt) = 0;
25
    virtual void OnDeath() = 0;
26

27
protected:
28
    float health, maxHealth, attackPower;
29
};
30

31
// 3. 独特行为的敌人
32
class Skeleton : public Enemy {
33
    bool hasRevived = false;
34
public:
35
    void OnDeath() override {
36
        if (!hasRevived) {
37
            hasRevived = true;
38
            health = maxHealth * 0.3f;  // 复活一次，30% 血
39
        } else {
40
            Destroy();
41
        }
42
    }
43
    void UpdateAI(float dt) override { /* 骷髅 AI */ }
44
};
45

46
// 4. 使用——完全配置驱动
47
for (auto& spawnPoint : levelConfig.enemySpawns) {
48
    auto enemy = EnemyRegistry::Create(spawnPoint.typeName, spawnPoint.config);
49
    scene->AddEnemy(std::move(enemy));
50
}

1
// ============ 抽象产品 ============
2
class IWeapon {
3
public:
4
    virtual int GetAttackPower() const = 0;
5
    virtual std::string GetName() const = 0;
6
    virtual ~IWeapon() = default;
7
};
8

9
class IArmor {
10
public:
11
    virtual int GetDefense() const = 0;
12
    virtual ~IArmor() = default;
13
};
14

15
class IAccessory {
16
public:
17
    virtual void OnEquip(Hero* hero) = 0;
18
    virtual ~IAccessory() = default;
19
};
20

21
// ============ 抽象工厂 ============
22
class IEquipmentFactory {
23
public:
24
    virtual std::unique_ptr<IWeapon> CreateWeapon() = 0;
25
    virtual std::unique_ptr<IArmor> CreateArmor() = 0;
26
    virtual std::unique_ptr<IAccessory> CreateAccessory() = 0;
27
    virtual ~IEquipmentFactory() = default;
28
};
29

30
// ============ 具体工厂：中世纪 ============
31
class MedievalFactory : public IEquipmentFactory {
32
    std::unique_ptr<IWeapon> CreateWeapon() override {
33
        return std::make_unique<Sword>(45);
34
    }
35
    std::unique_ptr<IArmor> CreateArmor() override {
36
        return std::make_unique<PlateArmor>(30);
37
    }
38
    std::unique_ptr<IAccessory> CreateAccessory() override {
39
        return std::make_unique<Amulet>("health_regen");
40
    }
41
};
42

43
// ============ 具体工厂：科幻 ============
44
class SciFiFactory : public IEquipmentFactory {
45
    std::unique_ptr<IWeapon> CreateWeapon() override {
46
        return std::make_unique<LaserGun>(60);
47
    }
48
    std::unique_ptr<IArmor> CreateArmor() override {
49
        return std::make_unique<PowerArmor>(40);
50
    }
51
    std::unique_ptr<IAccessory> CreateAccessory() override {
52
        return std::make_unique<ShieldBelt>(100);
53
    }
54
};
55

56
// ============ 使用方 —— 不再关心具体工厂类型 ============
57
void EquipSet(Hero* hero, IEquipmentFactory* factory) {
58
    hero->EquipWeapon(factory->CreateWeapon());
59
    hero->EquipArmor(factory->CreateArmor());
60
    hero->EquipAccessory(factory->CreateAccessory());
61
}
62

63
// 切换风格 = 切换工厂
64
auto medieval = std::make_unique<MedievalFactory>();
65
auto sciFi    = std::make_unique<SciFiFactory>();
66

67
EquipSet(player, medieval.get());  // 中世纪套装
68
EquipSet(player, sciFi.get());     // 科幻套装——同一段代码

1
// 棋类游戏中的"棋子工厂"是抽象工厂的经典应用
2
class IChessPieceFactory {
3
public:
4
    virtual std::unique_ptr<Piece> CreateKing() = 0;
5
    virtual std::unique_ptr<Piece> CreateQueen() = 0;
6
    virtual std::unique_ptr<Piece> CreateRook() = 0;
7
    virtual std::unique_ptr<Piece> CreateBishop() = 0;
8
    virtual std::unique_ptr<Piece> CreateKnight() = 0;
9
    virtual std::unique_ptr<Piece> CreatePawn() = 0;
10
    virtual ~IChessPieceFactory() = default;
11
};
12

13
// 国际象棋
14
class StandardChessFactory : public IChessPieceFactory { /* ... */ };
15

16
// 中国象棋——棋子种类不同
17
class ChineseChessFactory : public IChessPieceFactory { /* ... */ };
18

19
// 初始化棋局——同一段代码，换工厂换规则
20
void SetupBoard(Board* board, IChessPieceFactory* factory) {
21
    board->Place(factory->CreateKing(),  "e1");
22
    board->Place(factory->CreateQueen(), "d1");
23
    board->Place(factory->CreateRook(),  "a1");
24
    // ...
25
}

1
template<typename T>
2
class SimpleObjectPool {
3
public:
4
    T* Acquire() {
5
        if (pool.empty()) {
6
            return new T();  // 池空了，新建
7
        }
8
        T* obj = pool.front();
9
        pool.pop();
10
        obj->Reset();  // 重置状态——这是对象池的关键
11
        return obj;
12
    }
13

14
    void Release(T* obj) {
15
        pool.push(obj);  // 放回队列，不 delete
16
    }
17

18
    ~SimpleObjectPool() {
19
        while (!pool.empty()) {
20
            delete pool.front();
21
            pool.pop();
22
        }
23
    }
24

25
private:
26
    std::queue<T*> pool;
27
};
28

29
// 使用
30
SimpleObjectPool<Bullet> bulletPool;
31

32
void FireBullet(const Vector3& pos, const Vector3& dir) {
33
    auto* bullet = bulletPool.Acquire();
34
    bullet->SetPosition(pos);
35
    bullet->SetDirection(dir);
36
    bullet->SetActive(true);
37
    activeBullets.push_back(bullet);
38
}
39

40
void UpdateBullets() {
41
    for (auto* bullet : activeBullets) {
42
        if (bullet->IsOffScreen()) {
43
            bulletPool.Release(bullet);
44
        }
45
    }
46
}

1
template<typename T, size_t PoolSize>
2
class ObjectPool {
3
    static_assert(PoolSize > 0, "Pool size must be positive");
4

5
public:
6
    ObjectPool() {
7
        // 预分配一块连续内存
8
        pool.resize(PoolSize);
9
        // 初始化空闲链表——用索引而非指针，因为 vector 扩容时指针失效
10
        for (size_t i = 0; i < PoolSize; ++i) {
11
            freeList.push_back(i);
12
        }
13
    }
14

15
    T* Acquire() {
16
        if (freeList.empty()) {
17
            // 池已满——根据策略处理
18
            return nullptr;  // 策略1：返回空，调用方自己处理
19
            // 或者：回收最老的活跃对象——策略2
20
        }
21

22
        size_t index = freeList.back();
23
        freeList.pop_back();
24

25
        T* obj = &pool[index];
26
        obj->Reset();  // 调用对象的 Reset 方法
27
        activeMap[index] = obj;
28
        return obj;
29
    }
30

31
    void Release(T* obj) {
32
        // 通过指针偏移计算索引——因为 pool 是连续内存
33
        size_t index = obj - pool.data();
34
        if (index < PoolSize) {
35
            activeMap.erase(index);
36
            freeList.push_back(index);
37
        }
38
    }
39

40
    // 遍历所有活跃对象（无虚函数、连续内存、Cache-friendly）
41
    template<typename Func>
42
    void ForEachActive(Func&& func) {
43
        for (auto& [index, obj] : activeMap) {
44
            func(obj);
45
        }
46
    }
47

48
    size_t ActiveCount() const { return activeMap.size(); }
49
    size_t FreeCount() const { return freeList.size(); }
50

51
private:
52
    std::vector<T> pool;                          // 连续内存，无碎片
53
    std::vector<size_t> freeList;                 // 空闲索引列表
54
    std::unordered_map<size_t, T*> activeMap;     // 活跃对象索引
55
};
56

57
// 子弹类——必须提供 Reset()
58
class Bullet {
59
public:
60
    void Reset() {
61
        isActive = false;
62
        lifetime = 0.0f;
63
        position = Vector3::Zero();
64
        velocity = Vector3::Zero();
65
    }
66

67
    void Fire(const Vector3& pos, const Vector3& dir) {
68
        isActive = true;
69
        position = pos;
70
        velocity = dir.Normalized() * speed;
71
    }
72

73
    void Update(float dt) {
74
        if (!isActive) return;
75
        position += velocity * dt;
76
        lifetime += dt;
77
    }
78

79
    bool IsExpired() const { return lifetime > maxLifetime; }
80

81
private:
82
    Vector3 position;
83
    Vector3 velocity;
84
    float speed = 50.0f;
85
    float lifetime = 0.0f;
86
    float maxLifetime = 3.0f;
87
    bool isActive = false;
88
};
89

90
// 使用
91
ObjectPool<Bullet, 500> bulletPool;  // 预分配 500 发子弹
92

93
void FireBullet(const Vector3& pos, const Vector3& dir) {
94
    auto* bullet = bulletPool.Acquire();
95
    if (bullet) {
96
        bullet->Fire(pos, dir);
97
    }
98
}
99

100
void UpdateBullets(float dt) {
101
    bulletPool.ForEachActive([dt](Bullet* b) {
102
        b->Update(dt);
103
    });
104

105
    // 回收过期子弹
106
    std::vector<Bullet*> toRelease;
107
    bulletPool.ForEachActive([&](Bullet* b) {
108
        if (b->IsExpired()) toRelease.push_back(b);
109
    });
110
    for (auto* b : toRelease) {
111
        bulletPool.Release(b);
112
    }
113
}

1
简单队列池（离散内存）：
2
  Bullet[0] @ 0x1000
3
  Bullet[1] @ 0x3800   ← Cache miss
4
  Bullet[2] @ 0x1F00   ← Cache miss
5
  ...
6

7
预分配数组池（连续内存）：
8
  Bullet[0] @ 0x4000
9
  Bullet[1] @ 0x4080   ← 同一 Cache Line！64 字节内
10
  Bullet[2] @ 0x4100   ← 下一行，预取命中
11
  ...
12

13
遍历 500 发子弹：
14
  离散内存：~500 次 Cache Miss → 500 × 200 cycle ≈ 100,000 cycle
15
  连续内存：~500/4 = 125 次 Cache Miss → 125 × 200 cycle ≈ 25,000 cycle
16
  四倍差距。

1
// 完整的游戏对象池系统
2

3
// 1. 粒子池——数量大、生命周期短、丢几个无所谓
4
ObjectPool<Particle, 1000> particlePool;
5

6
// 2. 弹壳池——有上限，多了回收最老的
7
ObjectPool<ShellCasing, 50> shellPool;
8

9
// 3. 音效源池——数量有限（音频引擎限制），必须等待
10
ObjectPool<AudioSource, 32> audioSourcePool;
11

12
// 4. 伤害数字——UI 对象，使用后立即回收
13
ObjectPool<DamageNumber, 100> damageNumberPool;
14

15
void SpawnDamageNumber(const Vector3& worldPos, float damage) {
16
    auto* dn = damageNumberPool.Acquire();
17
    if (!dn) {
18
        // 池满了 —— 回收最老的伤害数字
19
        dn = FindOldestDamageNumber();
20
        damageNumberPool.Release(dn);
21
        dn = damageNumberPool.Acquire();
22
    }
23
    dn->Show(worldPos, damage, Color::Red);
24
    // 动画结束后 Release（在 Update 中检查）
25
}