// 這是一個典型的 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
// }