1
// 一个游戏中的典型场景——
2
// 你有很多不同类型的实体：玩家、NPC、怪物、道具...
3
// 它们都需要 Update() 和 Render()，但行为各不相同。
4

5
// 没有多态：
6
void UpdateAll(Player& p, NPC& n, Monster& m) {
7
    p.Update();
8
    n.Update();
9
    m.Update();  // 每加一种实体就改一次代码？不可能！
10
}
11

12
// 有多态：
13
class Entity {
14
public:
15
    virtual void Update() = 0;
16
    virtual void Render() = 0;
17
    virtual ~Entity() = default;
18
};
19

20
std::vector<std::unique_ptr<Entity>> entities;
21
for (auto& e : entities) {
22
    e->Update();  // 自动调用正确的派生类版本
23
    e->Render();  // 不管是 Player、NPC 还是 Monster
24
}

1
class Base {
2
public:
3
    ~Base() { std::cout << "~Base\n"; }  // ⚠️ 非虚析构！
4
};
5

6
class Derived : public Base {
7
    int* data;
8
public:
9
    Derived() : data(new int[1000]) {}
10
    ~Derived() {
11
        delete[] data;
12
        std::cout << "~Derived\n";
13
    }
14
};
15

16
Base* p = new Derived();
17
delete p;
18
// 输出：~Base
19
// ❌ Derived::~Derived 没有被调用 → data 内存泄漏！
20

21
// ✅ 修复：基类析构声明为 virtual
22
class Base {
23
public:
24
    virtual ~Base() { std::cout << "~Base\n"; }
25
};
26
// 现在 delete p 输出：~Derived ~Base ✅

1
// 纯虚函数：用 = 0 声明，没有默认实现
2
class Shape {
3
public:
4
    virtual double area() const = 0;        // 纯虚函数
5
    virtual void draw() const = 0;          // 纯虚函数
6
    virtual ~Shape() = default;
7
};
8

9
// Shape s;  // ❌ 编译错误！抽象类不能实例化
10

11
class Circle : public Shape {
12
    double radius;
13
public:
14
    Circle(double r) : radius(r) {}
15
    double area() const override { return 3.14159 * radius * radius; }
16
    void draw() const override { std::cout << "Drawing circle\n"; }
17
};
18

19
Circle c(5.0);  // ✅ 所有纯虚函数都 override 了
20

21
// 特殊情况：纯虚析构也需要提供实现！
22
class AbstractBase {
23
public:
24
    virtual ~AbstractBase() = 0;  // 纯虚析构
25
};
26
// 必须在类外提供实现（因为派生类析构时会调用它）：
27
AbstractBase::~AbstractBase() = default;

1
struct Base1 {
2
    virtual void foo() { std::cout << "Base1::foo\n"; }
3
    int a = 1;
4
};
5

6
struct Base2 {
7
    virtual void bar() { std::cout << "Base2::bar\n"; }
8
    int b = 2;
9
};
10

11
struct Multi : Base1, Base2 {
12
    void foo() override { std::cout << "Multi::foo\n"; }
13
    void bar() override { std::cout << "Multi::bar\n"; }
14
    int c = 3;
15
};
16

17
Multi m;
18

19
// 指针调整
20
Base1* p1 = &m;   // p1 == &m（无调整，Base1 在最前面）
21
Base2* p2 = &m;   // p2 == (char*)&m + sizeof(Base1子对象)
22
                   // p2 的值和 p1 不同！
23

24
std::cout << "m:  " << &m  << "\n";   // 0x100
25
std::cout << "p1: " << p1  << "\n";   // 0x100（相同）
26
std::cout << "p2: " << p2  << "\n";   // 0x110（偏移了 16 字节）

1
struct A {
2
    int x = 100;
3
    virtual void hello() { std::cout << "A::hello\n"; }
4
};
5

6
// 不使用虚继承 → 菱形问题
7
struct B_bad : A { int y = 200; };
8
struct C_bad : A { int z = 300; };
9
struct D_bad : B_bad, C_bad { int w = 400; };
10

11
D_bad d_bad;
12
// d_bad.x;           // ❌ 编译错误！歧义：是 B::A::x 还是 C::A::x？
13
d_bad.B_bad::x = 10;  // ✅ 必须显式指定
14
d_bad.C_bad::x = 20;  // ✅ 不同的 x！
15

16
// 使用虚继承 → 解决菱形问题
17
struct B : virtual A { int y = 200; };
18
struct C : virtual A { int z = 300; };
19
struct D : B, C { int w = 400; };
20

21
D d;
22
d.x = 42;             // ✅ 只有一份 A::x，无歧义
23

24
// 虚继承的内存布局：
25
// D 对象: [B子对象: vbptr, y] [C子对象: vbptr, z] [w] [共享的A: vptr, x]
26
//          ↑                    ↑                        ↑
27
//   虚基类指针(vbptr)     虚基类指针(vbptr)         A 只存一份
28
//   指向虚基类表(vbtable)   指向虚基类表
29
//   记录从自身到 A 子对象的偏移

1
// === static_cast：最常用 ===
2
// 基本类型转换
3
double d = 3.14;
4
int i = static_cast<int>(d);        // 3（截断，明确意图）
5

6
// 向上转换（安全的，隐式就行）
7
Derived  der;
8
Base*    bp = static_cast<Base*>(&der);     // ✅ 总是安全
9

10
// 向下转换（危险：你必须确保类型正确）
11
Base*    bp2 = new Derived();
12
Derived* dp  = static_cast<Derived*>(bp2);  // ✅ 实际是 Derived，安全
13
// Unrelated* up = static_cast<Unrelated*>(bp2); // ❌ 编译错误！无继承关系
14

15
// void* 转换
16
void*    vp = static_cast<void*>(&der);
17
Derived* dp2 = static_cast<Derived*>(vp);   // ✅ 你必须知道原始类型
18

19
// === dynamic_cast：安全但慢 ===
20
Base* bp3 = new Derived();
21
Derived* dp3 = dynamic_cast<Derived*>(bp3);  // ✅ 运行时检查，安全
22
// 要求：Base 必须有虚函数（否则编译错误）
23

24
// === const_cast：移除 const ===
25
const int cx = 42;
26
int* px = const_cast<int*>(&cx);
27
*px = 100;  // ⚠️ 未定义行为！cx 本身是 const
28
// const_cast 主要用于接口适配：
29
void legacy_api(char* s);       // 接受非 const
30
const char* str = "hello";
31
legacy_api(const_cast<char*>(str));  // 如果 legacy_api 不修改 s，这是安全的
32

33
// === reinterpret_cast：最危险 ===
34
int value = 0x42;
35
float* fp = reinterpret_cast<float*>(&value);  // 按位解释为 float
36
// 常见用途：序列化、网络字节操作、与 C API 交互
37
uintptr_t addr = reinterpret_cast<uintptr_t>(&value);  // 指针转整数

1
// === 题目 1：构造函数中调用虚函数 ===
2
struct A {
3
    A() { print(); }
4
    virtual void print() { std::cout << "A\n"; }
5
};
6
struct B : A {
7
    void print() override { std::cout << "B\n"; }
8
};
9
B b;
10
// 输出：A
11
// 原因：B 的构造过程中，先调 A::A()，此时 vptr 指向 A::vtable → 调 A::print()
12

13
// === 题目 2：没有虚析构的 delete ===
14
struct X {
15
    ~X() { std::cout << "~X "; }   // 非虚！
16
};
17
struct Y : X {
18
    int* data = new int[100];
19
    ~Y() { delete[] data; std::cout << "~Y "; }
20
};
21
X* p = new Y();
22
delete p;
23
// 输出：~X
24
// ❌ ~Y 没有调用 → data 泄漏！
25

26
// === 题目 3：切片问题 (Slicing) ===
27
struct Base { virtual void f() { std::cout << "Base\n"; } int x = 1; };
28
struct Derived : Base { void f() override { std::cout << "Derived\n"; } int y = 2; };
29

30
Derived d;
31
Base b = d;    // ⚠️ 切片！d 的 Derived 部分被切掉了
32
b.f();         // 输出：Base（不是 Derived！）
33
// b 是 Base 类型的对象（不是指针/引用），vptr 指向 Base::vtable
34

35
Base& ref = d;
36
ref.f();       // 输出：Derived ✅ 引用保持多态
37

38
// === 题目 4：override 和 final ===
39
struct Base2 {
40
    virtual void foo(int) {}
41
};
42
struct Derived2 : Base2 {
43
    void foo(double) override {}  // ❌ 编译错误！参数类型不同，不是 override
44
    // 如果没有 override 关键字，编译通过但不会覆盖，变成隐藏（hiding）
45
};
46

47
// === 题目 5：隐藏 vs 覆盖 ===
48
struct Base3 {
49
    virtual void func(int x) { std::cout << "Base3::func(int)\n"; }
50
    void func(double x) { std::cout << "Base3::func(double)\n"; }
51
};
52
struct Derived3 : Base3 {
53
    void func(int x) override { std::cout << "Derived3::func(int)\n"; }
54
    // 注意：Base3::func(double) 被隐藏了！
55
};
56

57
Derived3 d3;
58
d3.func(42);    // ✅ Derived3::func(int)
59
// d3.func(3.14); // ⚠️ 调用 Derived3::func(int)（double 被隐式转换为 int）
60
// 如果想保留基类的重载版本：using Base3::func;
61

62
// === 题目 6：析构顺序 ===
63
struct P { P() { std::cout << "P "; } ~P() { std::cout << "~P "; } };
64
struct Q : P { Q() { std::cout << "Q "; } ~Q() { std::cout << "~Q "; } };
65
struct R : Q { R() { std::cout << "R "; } ~R() { std::cout << "~R "; } };
66

67
{ R r; }
68
// 输出：P Q R ~R ~Q ~P
69
// 构造：基类→派生类  析构：派生类→基类

1
// 游戏实体的经典继承设计
2
class Entity {
3
protected:
4
    uint32_t _id;
5
    std::string _name;
6
    float _x = 0, _y = 0, _z = 0;
7

8
public:
9
    Entity(uint32_t id, std::string name)
10
        : _id(id), _name(std::move(name)) {}
11

12
    virtual void Update(float dt) = 0;
13
    virtual void Render() = 0;
14
    virtual void OnCollision(Entity& other) {}  // 默认空实现
15

16
    virtual ~Entity() = default;
17

18
    uint32_t getId() const { return _id; }  // 非虚：不需要多态
19
};
20

21
class Character : public Entity {
22
protected:
23
    float _hp, _maxHp;
24
    float _speed;
25

26
public:
27
    Character(uint32_t id, std::string name, float hp, float speed)
28
        : Entity(id, std::move(name)), _hp(hp), _maxHp(hp), _speed(speed) {}
29

30
    virtual void TakeDamage(float dmg) {
31
        _hp = std::max(0.f, _hp - dmg);
32
        if (_hp <= 0) OnDeath();
33
    }
34

35
    virtual void OnDeath() = 0;
36
};
37

38
class Player : public Character {
39
public:
40
    Player(uint32_t id, std::string name)
41
        : Character(id, std::move(name), 100.f, 5.f) {}
42

43
    void Update(float dt) override {
44
        // 读取输入 → 移动 → 动画状态机
45
    }
46
    void Render() override { /* 渲染玩家模型 */ }
47
    void OnDeath() override { /* 播放死亡动画，等待重生 */ }
48
};
49

50
class Monster : public Character {
51
    float _attackRange;
52
public:
53
    Monster(uint32_t id, std::string name, float hp, float range)
54
        : Character(id, std::move(name), hp, 3.f), _attackRange(range) {}
55

56
    void Update(float dt) override {
57
        // AI 状态机：巡逻 → 追踪 → 攻击
58
    }
59
    void Render() override { /* 渲染怪物模型 */ }
60
    void OnDeath() override { /* 掉落物品，播放消亡特效 */ }
61
};

1
// ❌ 热路径中的虚函数（每帧百万次调用）
2
class Particle {
3
public:
4
    virtual void Update(float dt) {  // 每帧每粒子调用 → 百万次虚函数调用！
5
        x += vx * dt;
6
        y += vy * dt;
7
    }
8
    float x, y, vx, vy;
9
};
10

11
// ✅ 数据驱动替代方案（零虚函数开销）
12
struct ParticleData {
13
    std::vector<float> x, y, vx, vy;  // SoA 布局
14
    size_t count;
15
};
16

17
void UpdateParticles(ParticleData& p, float dt) {
18
    for (size_t i = 0; i < p.count; ++i) {
19
        p.x[i] += p.vx[i] * dt;
20
        p.y[i] += p.vy[i] * dt;
21
    }
22
    // 无虚函数、无间接调用、可自动向量化 (SIMD)
23
}

1
// 组件模式：用组合替代继承
2
struct Position { float x, y, z; };
3
struct Velocity { float vx, vy, vz; };
4
struct Health   { float current, max; };
5
struct AIState  { enum { Idle, Chase, Attack } state; };
6
struct Renderable { uint32_t mesh_id, material_id; };
7

8
// 实体只是一个 ID + 组件集合
9
using Entity = uint32_t;
10

11
// 系统（System）处理特定组件组合
12
void MovementSystem(
13
    std::vector<Position>& positions,
14
    const std::vector<Velocity>& velocities,
15
    float dt)
16
{
17
    for (size_t i = 0; i < positions.size(); ++i) {
18
        positions[i].x += velocities[i].vx * dt;
19
        positions[i].y += velocities[i].vy * dt;
20
        positions[i].z += velocities[i].vz * dt;
21
    }
22
    // 零虚函数、SoA 布局、缓存友好、可 SIMD
23
}
24

25
// 想要一个"飞行的、会攻击的、可骑乘的怪物"？
26
// 继承：需要 FlyingMountableAttackingMonster 类 😰
27
// ECS：给实体挂 Position + Velocity + Fly + Mountable + Attack + AI 组件 ✅

1
// 注册表 + 工厂函数
2
class EntityFactory {
3
    using CreatorFunc = std::function<
4
        std::unique_ptr<Entity>(uint32_t id, const Config& cfg)
5
    >;
6

7
    std::unordered_map<std::string, CreatorFunc> _creators;
8

9
public:
10
    // 注册一种实体类型
11
    void registerType(const std::string& typeName, CreatorFunc creator) {
12
        _creators[typeName] = std::move(creator);
13
    }
14

15
    // 根据配置创建实体
16
    std::unique_ptr<Entity> create(const Config& cfg) {
17
        auto it = _creators.find(cfg.typeName);
18
        if (it == _creators.end()) {
19
            throw std::runtime_error("Unknown entity type: " + cfg.typeName);
20
        }
21
        return it->second(nextId(), cfg);
22
    }
23

24
private:
25
    uint32_t _nextId = 0;
26
    uint32_t nextId() { return ++_nextId; }
27
};
28

29
// 使用：
30
EntityFactory factory;
31

32
// 注册所有类型（通常在引擎初始化时）
33
factory.registerType("Player", [](uint32_t id, const Config& cfg) {
34
    return std::make_unique<Player>(id, cfg.getString("name"));
35
});
36
factory.registerType("Monster", [](uint32_t id, const Config& cfg) {
37
    return std::make_unique<Monster>(
38
        id, cfg.getString("name"),
39
        cfg.getFloat("hp"), cfg.getFloat("attackRange")
40
    );
41
});
42

43
// 从关卡文件创建所有实体
44
for (auto& entityCfg : levelData.entities) {
45
    auto entity = factory.create(entityCfg);
46
    world.addEntity(std::move(entity));
47
    // 不管是 Player、Monster 还是 NPC——
48
    // 工厂返回 unique_ptr<Entity>，通过虚函数统一调用
49
}