原来 C++ 虚函数是这样实现的！

// 这是一个典型的 C++ 类定义 🏗️
class Rectangle {
public:
    // 构造函数，初始化宽和高 ✨
    Rectangle(int w, int h) : width(w), height(h) {}
    
    // 计算面积的成员函数 📐
    int area() { return width * height; }
    
private:
    int width;   // 矩形的宽 📏
    int height;  // 矩形的高 📏
};

// C 语言结构体定义 🔨
struct Rectangle {
    int width;   // 存储宽度
    int height;  // 存储高度
};

// 构造函数被转换为普通的 C 函数 🛠️
void Rectangle_Rectangle(
    struct Rectangle* this, 
    int w, 
    int h
) {
    this->width = w;
    this->height = h;
}

// 成员函数也变成普通的 C 函数 🔧
int Rectangle_area(struct Rectangle* this) {
    returnthis->width * this->height;
}

// 一个简单的学生类 👨🎓
class Student {
    std::string name;     // 存储学生姓名 📝
    int score;           // 记录考试分数 💯
    void study();       // 学习方法 📚
    void doHomework();  // 写作业功能 ✏️
};

// 在内存中的实际表示
struct Student_Internal {
    void* name_ptr;      // 指向实际的 string 数据
    void* score_ptr;     // 指向实际的 int 数据
    void* study_ptr;     // 指向 study 函数
    void* homework_ptr;  // 指向 homework 函数
};

// 创建一个学生对象
Student student;  

// 在内存中占用 32 字节
// 因为有 4 个指针，每个指针 8 字节
// 4 × 8 = 32 字节 📏

// 简单对象模型下访问成员的复杂过程 🔍
void useStudent(Student* s) {
    // 第一步：定位 score 指针的地址 📍
    void** score_ptr_addr = (void**)((char*)s + sizeof(void*));
    
    // 第二步：通过指针找到实际分数 🎯
    int* real_score = (int*)(*score_ptr_addr);
    
    // 第三步：终于可以修改分数了 ✏️
    *real_score = 100;

    // 调用方法更复杂 😱
    // 第一步：找到函数指针的地址 🔍
    void** study_ptr_addr = (void**)((char*)s + 2 * sizeof(void*));
    
    // 第二步：获取实际的函数指针 🎯
    void (*study_func)(Student*) = 
        (void (*)(Student*))*study_ptr_addr;
    
    // 第三步：调用函数 🚀
    study_func(s);
}

// 学生类的原始定义 👨🎓
class Student {
    std::string name;    // 学生姓名
    int score;          // 学生分数
    void study();      // 学习方法
    void doHomework(); // 做作业方法
};

// ===== 表格驱动模型的内部实现 =====

// 数据部分:专门存储成员变量 📝
struct Student_Data {
    std::string name;  // 直接存储姓名
    int score;        // 直接存储分数
};

// 表格部分:管理数据和函数 📋
struct Student_Table {
    // 指向实际数据的指针
    Student_Data* data;     
    
    // 指向函数表的指针(存储所有成员函数)
    void** function_table;   
};

// 问题演示 1: 内存占用问题 💾
struct Student_Table {
    Student_Data* data;      // 8字节
    void** function_table;   // 8字节
};  // 总共需要 16 字节!

// 问题演示 2: 访问效率问题 🐌
void example() {
    Student s;
    
    // 访问数据要两次解引用 
    int score = s.table->data->score;  
    
    // 调用函数更复杂
    void (*func)() = s.table->function_table[0];
    func();
}

// 现代 C++ 对象模型示例 🎯
class ModernStudent {
    // 数据直接存储在对象中 📝
    std::string name;   
    int score;         
    
    // 普通函数直接编译为独立函数 🔨
    void study() { 
        // 直接访问数据成员
        score += 10;  
    }
    
    // 虚函数才使用虚表 🌟
    virtual void doHomework() {
        // 通过虚表调用
    }
    
private:
    // 只有需要多态的类才有虚表指针
    void* vptr;  // 虚函数表指针 📍
};

// 动物基类 🦁
class Animal {
public:
    // 构造函数,初始化动物名字 🏗️
    Animal(conststd::string& name) : _name(name) {}
    
    // 虚析构函数,确保正确释放内存 🗑️
    virtual ~Animal() = default;
    
    // 纯虚函数,所有动物都要实现发声 🔊
    virtual void makeSound() = 0;  
    
protected:
    std::string _name;    // 动物的名字 📝
    
private:
    staticint population;  // 所有动物的数量统计 📊
};

// 猫咪类 - 继承自动物 🐱
class Cat :public Animal {
public:
    // 构造小猫咪 🐱
    Cat(conststd::string& name) : Animal(name) {}
    
    // 实现猫咪的叫声 🔊
    virtual void makeSound() override { 
        std::cout << "喵喵喵~" << std::endl; 
    }
    
private:
    int _lives = 9;  // 猫有9条命 ✨
};

// Animal 在内存中的实际布局 📐
struct Animal_Layout {
    void* vptr;         // 虚函数表指针 🔍
    std::string _name;  // 名字成员变量 📝
};

// Cat 在内存中的实际布局 📏
struct Cat_Layout {
    Animal_Layout base;  // 继承的基类部分 👆
    int _lives;         // Cat独有的成员 🎯
};

// 类外部的静态成员 📦
static int Animal::population;  // 存储在数据段中

Cat kitty("咪咪");  // 创建猫咪对象

kitty.makeSound();  // 看起来很简单的一行代码

// 第一步：获取对象的虚表指针
void** vptr = *(void***)(&kitty);  // 从对象内存布局的开始位置读取虚表指针

// 指针层次分析:
// === 第1步：获取对象地址 ===
Cat* cat_ptr = &kitty;
// cat_ptr 现在指向对象的起始位置
// 因为虚表指针总是在对象的最开始位置，所以这个地址
// 实际上就指向了虚表指针的存储位置

// === 第2步：转换为 void*** 类型 ===
void*** triple_ptr = (void***)cat_ptr;
// 为什么要转换成 void***？
// - 因为我们要通过这个指针去读取虚表指针
// - 虚表指针本身的类型是 void**
// - 所以指向虚表指针的指针就是 void***

// === 第3步：解引用获取虚表指针 ===
void** vptr = *triple_ptr;
// 现在 vptr 就是真正的虚表指针了
// - 它指向了函数指针数组（虚函数表）
// - 类型是 void**，因为它指向的是函数指针数组

// 内存布局示意：
/*
内存地址     内容                  类型
0x1000   [ 虚表指针 ]            void**    <-- cat_ptr/triple_ptr 指向这里
         [ name成员 ]            string
         [ lives成员 ]           int

0x2000   [ 析构函数指针 ]        void*     <-- vptr 指向这里（虚函数表的开始）
         [ makeSound指针 ]       void*
         [ eat指针 ]            void*
         [ purr指针 ]           void*
*/

// 假设有一个 Cat 对象
Cat kitty("咪咪");

// 获取虚表指针的详细步骤分解
void** vptr = *(void***)(&kitty);

/* 让我们一步步解析这行代码:

1. &kitty 得到 Cat* 类型
   - 这是对象的起始地址
   - 因为虚表指针在对象的开头，所以这个地址就是虚表指针的位置

2. (void***) 转换
   - 为什么需要 void***？
   - 因为我们要:
     a) 首先通过指针访问对象 (第一个*)
     b) 对象开头存储的是虚表指针 (第二个*)
     c) 虚表本身是函数指针数组 (第三个*)
   - 这就像一个三层的包装盒:
     最外层: 对象地址
     中间层: 虚表指针
     最内层: 函数指针数组

3. *(void***) 解引用
   - 这一步实际获取了虚表指针
   - 结果类型是 void**，正好是函数指针数组的类型
*/

// 想象一个三维数组结构
Class[N][M][K] objects;

/*
三个维度分别代表:
第一维 [N]: 不同的类
    - 每个类都有自己的虚函数表
    - 比如 Animal、Cat、Dog 等类

第二维 [M]: 虚函数表
    - 存储了该类所有的虚函数指针
    - 包括继承的、覆写的和新增的函数

第三维 [K]: 具体的函数指针
    - 指向实际的函数实现
    - 比如 makeSound、eat 等方法

访问过程就像在这个三维空间中导航:
1. 通过对象找到对应的类 (第一维)
2. 获取该类的虚函数表 (第二维)
3. 在表中找到具体的函数指针 (第三维)
*/

// 用代码表示这个访问过程
void callVirtualFunction(Cat* obj, int funcIndex) {
    // 第一维：通过对象找到类的虚表指针
    void*** classPtr = (void***)obj;
    
    // 第二维：获取虚函数表
    void** vtable = *classPtr;
    
    // 第三维：获取具体函数指针
    void* funcPtr = vtable[funcIndex];
    
    // 调用函数
    ((void(*)(Cat*))funcPtr)(obj);
}

// 第二步：在虚表中查找函数地址
void (*makeSound)(Cat*) = vptr[1];  // 虚表中查找 makeSound 函数指针

// Animal 类的虚函数表布局 📋
struct Animal_VTable {
    // [0] 析构函数永远在第一个位置
    void (*destructor)(Animal*);     
    // [1] makeSound 在第二个位置
    void (*makeSound)(Animal*);      
    // 如果还有其他虚函数，继续往后排...
};

// Cat 类继承并覆写了这些函数
struct Cat_VTable {
    // [0] Cat 的析构函数
    void (*destructor)(Cat*);        
    // [1] Cat 的 makeSound 实现
    void (*makeSound)(Cat*);         
};

class Animal {
public:
    virtual ~Animal();                // 位置 [0]
    virtual void makeSound() = 0;     // 位置 [1]
    virtual void eat();               // 位置 [2]
};

class Cat : public Animal {
public:
    virtual ~Cat();                   // 位置 [0]
    virtual void makeSound() override;// 位置 [1]
    virtual void eat() override;      // 位置 [2]
    virtual void purr();              // 位置 [3] - Cat特有
};

// 第三步：调用找到的函数
makeSound(&kitty);  // 传入 this 指针调用函数

// 内存布局示意图 📝

// 代码段（只读）中存储的虚函数表
const Cat_VTable {              // 📋 所有 Cat 对象共享这个表
    &Cat::destructor,          // [0]
    &Cat::makeSound,          // [1]
    &Cat::eat,               // [2]
    &Cat::purr              // [3]
};

// 堆/栈中的对象
Cat cat1("咪咪");   // 🐱 对象1
// {
//     vptr -> Cat_VTable    // 指向共享的虚函数表
//     name: "咪咪"
//     lives: 9
// }

Cat cat2("花花");   // 🐱 对象2
// {
//     vptr -> Cat_VTable    // 指向相同的虚函数表
//     name: "花花"
//     lives: 9
// }

// 基类 Animal 的虚函数表
const Animal_VTable {           // 🦁 基类表
    &Animal::destructor,       // [0]
    &Animal::makeSound,       // [1]
    &Animal::eat             // [2]
};

// 派生类 Cat 的虚函数表
const Cat_VTable {             // 🐱 派生类有自己的表
    &Cat::destructor,         // [0] 覆写的析构函数
    &Cat::makeSound,         // [1] 覆写的 makeSound
    &Cat::eat,              // [2] 覆写的 eat
    &Cat::purr             // [3] Cat 特有的函数
};

// 内存中的对象
Animal* p1 = new Animal();  // 基类对象
// {
//     vptr -> Animal_VTable   // 指向 Animal 的表
//     name: "动物"
// }

Animal* p2 = new Cat();     // 通过基类指针指向派生类对象
// {
//     vptr -> Cat_VTable      // 指向 Cat 的表！
//     name: "咪咪"
//     lives: 9
// }