C++中多態與多重繼承實現的sli

這篇文章將為大家詳細講解有關C++中多態與多重繼承實現的sli，小編覺得挺實用的，因此分享給大家做個參考，希望大家閱讀完這篇文章后可以有所收獲。

C++ 多態的虛指針實現

首先討論 C++. 多態也即子類對父類成員函數進行了重寫 (Override) 后，將一個子類指針賦值給父類，再對這個父類指針調用成員函數，會調用子類重寫版本的成員函數。簡單的例子：

class Parent1 {
  public:
  virtual void sayHello() { printf("Hello from parent1!\n"); }
};

class Child : public Parent1 {
  public:
  virtual void sayHello() { printf("Hello from child!\n"); }
};

int main() {
  Parent1 *p = new Child();
  p->sayHello();  // get "Hello from child!"
}

首先需要明白，對于底層實現而言，成員函數就是第一個參數為對象指針的函數，編譯器自動將對象指針添加到函數參數中并命名為 this 指針，除此之外與普通函數并無本質不同。對于非多態的成員函數調用，與非成員函數調用過程基本是一致的，根據參數列表（參數列表中包含對象指針類型）和函數名在編譯時確定實際調用的函數。

為了實現多態，不能只根據對象指針類型推斷函數簽名，也即例子中，p->sayHello() 這一行代碼在執行時不能只根據 p 的類型確認調用的函數應該是 Parent::sayHello 還是 Child:sayHello。在多態機制下，每個類父類和子類都需要在其數據結構中多攜帶一個指針，這個指針指向該類的虛函數表。

類的虛函數表也即所有可能發生重寫的函數指針表，對象創建時根據其實際類型決定其虛函數指針指向的虛函數列表。如在上文的例子中，Parent1 和 Child 類的虛函數列表都只有一個函數，分別是 Parent1::sayHello 和 Child::sayHello. 編譯器在編譯時將會把函數調用翻譯為「引用虛函數表中的第 N 個函數」這樣的指令，比如本例中翻譯為「引用虛函數表中第一個函數」。在運行時讀取虛函數表中真正的函數指針。運行時 CPU 代價基本是一次指針解引用和一次下表訪問。

Parent1 和 Child 對象都沒有自定義的數據結構。運行以下代碼能夠確認 Parent1 和 Child 對象的真實數據結構大小都是 8 字節，也即只有虛函數列表指針。把 Parent1 和 Child1 對象作為 64 位整數輸出，可以看到 p1, p2 的值相同，p3 與前兩者不同。這個值也即相應類的虛函數表地址。

Parent1* p1 = new Parent1();
Parent1* p2 = new Parent1();
Parent1* p3 = new Child();
printf("sizeof Parent1: %d, sizeof Child: %d\n",
  sizeof(Parent1), sizeof(Child));
printf("val on p1: %lld\n", *(int64_t*)p1);
printf("val on p2: %lld\n", *(int64_t*)p2);
printf("val on p3: %lld\n", *(int64_t*)p3);

C++ 多態與多重繼承

有一個非常有意思的問題：C++ 發生多重繼承時，如何支持多態。剛剛提到，多態的原理是編譯器將成員函數調用編譯為「引用虛函數表中第 N 個函數」，虛函數表在對象數據結構中的位置和要調用虛函數列表中的第幾個函數在編譯時都是需要確定的。多重繼承對象如果只有一個虛函數列表，那不同父類的虛函數列表中的位置就要發生沖突。如果有多個虛函數列表，編譯時就難以確定虛函數列表指針在數據結構中的位置。C++ 采取了非常精妙的做法：將所有父類的數據結構（包括虛指針列表）在該對象的數據結構上依次排列，該對象的指針正常指向數據結構起始位置。當指針發生類型轉換時，C++ 編譯器會對指針的值盡可能的進行調整，使其指向該指針類型應該對應的位置。指針的值在這個過程中發生了變化。

比如，Child 類繼承了 Parent1, Parent2 兩個類，則在 Child 指針轉換為 Parent1 指針時，不對指針的值進行調整，因為 Parent1 是 Child 的第一個父類。但將 Child 轉換為 Parent2 時，需要將指針指增加 Parent1 數據結構長度的值，使指針指向對應 Parent2 數據結構開始位置。在本例子中，Parent1 數據結構只有虛函數列表指針，在 64 位機器上長度為 8. 因此，在 Child 指針轉換為 Parent2 指針時，其值增加了 8.

class Parent1 {
  public:
  virtual void sayHello() { printf("Hello from parent1!\n"); }
};

class Parent2 {
  public:
  virtual void sayHi() { printf("Hi from Parent2!\n"); }
};

class Child : public Parent1, public Parent2 {
  public:
  virtual void sayHello() { printf("Hello from child!\n"); }
  virtual void sayHi() { printf("Hi from child!\n"); }
};

int main() {
  Child *p = new Child();
  printf("size of Child: %d", sizeof(Child));
  printf("pointer val as Child*: %lld\n", int64_t(p));
  printf("pointer val as Parent1*: %lld\n", int64_t((Parent1*)p));
  printf("pointer val as Parent2*: %lld\n", int64_t((Parent2*)p));
}

運行這段代碼，會發現 Child 數據結構大小增長到 16，也即兩個指針。并且指針的值在后兩次類型轉換時是不同的，在 64 位機器上相差 8 個字節，也即 Parent1 的數據結構大小。另外如果將 p 轉換成 Void 指針再轉換為 Parent 指針，此時編譯器就不能正確推斷這個偏移量，此時就會發生未定義行為。

這個特性其實說明了一個非常有意思的事實：C++ 編譯器在編譯時能夠推斷指針的偏移量，那么編譯器也應該可以推斷該指針指向對象的真實類型。那么，既然可以編譯時推斷對象真實類型，那要虛函數表又有何用？直接推斷正確的函數調用不就可以了嗎？問題在于，如果真的在編譯時推斷多態函數調用，就意味著要為不同類型的對象生成不一樣的二進制代碼。同一行代碼，根據指針值的不同，產生的函數調用不同。這樣一來也意味第三方庫需要提供源代碼，來進行相關的推斷，類似于模板庫。這都是不可接受的，因此虛函數列表仍然有必要。借助虛函數列表，使用指針的代碼能夠生成一致的機器碼。
從另一個角度理解，編譯器在編譯一個完整的 App 時確實能夠推斷所有變量的真實類型，但這需要聯系過多上下文。編譯一段代碼卻需要這段代碼輸入參數的除類型之外的上下文信息，并根據上下文信息生成不同的二進制文件，這是不可接受的。

Java 多態比較

由于 Java 的多態機制比 C++ 簡單，理論上可以使用 C++ 的機制實現 Java 多態。但 C++ 跟 Java 有一點決定性的不同：C++ 要求父類成員方法必須有 Virtual 關鍵字修飾時才能被重寫。這就意味著編譯器在編譯父類時就能確認那些函數可能被重寫，于是可以對不可能重寫的函數直接在編譯時決定調用的具體函數，而對可能重寫的函數使用虛指針表處理。而 Java 的方法默認都是可以重寫的，因此可以認為 Java 方法調用都需要經過查詢虛函數列表的過程，會比 C++ 不重寫函數多一點開銷。

Java 不支持多重繼承，但 Java 支持接口 Interface, 接口跟多重繼承有相似之處，不能簡單的使用一個虛函數表查找。類需要為其實現的每個 Interface 生成一個虛函數列表，跟 C++ 的情況類似。OpenJDK 文檔指出，在類定義中找到 Interface 的虛函數列表的辦法是很粗暴的：在類實現的所有 Interface 列表中遍歷查找。文檔中指出，真正的多重繼承是罕見的，通常可以歸結為單繼承。對此遍歷過程可能有各種優化，筆者沒有深入了解。

思考 Java 和 C++ 的一點不同：C++ 沒有運行時類型，由編譯器在編譯時盡力保證指針指向的位置有對象正確的數據結構。將子類指針賦值給父類指針變量時，編譯器盡力對其進行調整，但如果發生了 Void 指針賦值等，則編譯器無法保證指針指向的位置有正確的對象數據結構。這一步只要語法上沒有錯誤，就不會立即報錯，編譯器也無法確認是否會發生問題，一定要等到該指針實際進行解引用等發生異常才會報錯。Java 有運行時類型，在將對象賦值給不同的類型的變量時，會在運行時進行類型檢查，如果沒有正確的類型繼承關系，會在賦值時報錯。

另外，對比 Java 的 Interface 和 C++ 的多重繼承，會發現 Interface 的運行時時間開銷要比 C++ 多重繼承大得多。但是 C++ 多重繼承需要為每個父類附加一個指針，并且編譯器在編譯時需要完成更多的工作。Java 相對于 C++ 是更加「強類型」的語言。

關于“C++中多態與多重繼承實現的sli”這篇文章就分享到這里了，希望以上內容可以對大家有一定的幫助，使各位可以學到更多知識，如果覺得文章不錯，請把它分享出去讓更多的人看到。