c++繼承中的記憶體布局

 今天在網上看到了一篇寫得非常好的文章，是有關c++類繼承記憶體布局的。看了之後獲益良多，現在轉在我自己的部落格裡面，作為以後複習之用。

——談VC++物件模型
（美）簡.格雷
程化    譯

譯者前言

一個C++程式員，想要進一步提升技術水平的話，應該多瞭解一些語言的語意細節。對於使用VC++的程式員來說，還應該瞭解一些VC++對於C++的詮釋。 Inside the C++ Object Model雖然是一本好書，然而，書的篇幅多一些，又和具體的VC++關係小一些。因此，從篇幅和內容來看，譯者認為本文是深入理解C++物件模型比較好的一個出發點。
這篇文章以前看到時就覺得很好，舊文重讀，感覺理解得更多一些了，於是產生了翻譯出來，與大家共用的想法。雖然文章不長，但時間有限，又若干次在翻譯時打盹睡著，拖拖拉拉用了小一個月。
一方面因本人水平所限，另一方面因翻譯時經常打盹，錯誤之處恐怕不少，歡迎大家批評指正。

本文原文出處為MSDN。如果你安裝了MSDN，可以搜尋到C++ Under the Hood。否則也可在網站上找到 http://msdn.microsoft.com/archive/default.asp?url=/archive/en-us/dnarvc/html/jangrayhood.asp 。

1 前言

瞭解你所使用的程式設計語言究竟是如何?的，對於C++程式員可能特別有意義。首先，它可以去除我們對於所使用語言的神秘感，使我們不至於對於編譯器乾的活感到完全不可思議；尤其重要的是，它使我們在Debug和使用語言進階特性的時候，有更多的把握。當需要提高代碼效率的時候，這些知識也能夠很好地協助我們。

本文著重回答這樣一些問題：
1* 類如何布局。
2* 成員變數如何訪問。
3* 成員函數如何訪問。
4* 所謂的“調整塊”（adjuster thunk）是怎麼回事。
5* 使用如下機制時，開銷如何：
  * 單繼承、多重繼承、虛繼承
  * 虛函數調用
  * 強制轉換到基類，或者強制轉換到虛基類
  * 異常處理
首先，我們順次考察C相容的結構（struct）的布局，單繼承，多重繼承，以及虛繼承；
接著，我們講成員變數和成員函數的訪問，當然，這裡麵包含虛函數的情況；
再接下來，我們考察建構函式，解構函式，以及特殊的賦值操作符成員函數是如何工作的，數組是如何動態構造和銷毀的；
最後，簡單地介紹對異常處理的支援。

對每個語言特性，我們將簡要介紹該特性背後的動機，該特性自身的語意（當然，本文決不是“C++入門”，大家對此要有充分認識），以及該特性在微軟的 VC++中是如何?的。這裡要注意區分抽象的C++語言語意與其特定實現。微軟之外的其他C++廠商可能提供一個完全不同的實現，我們偶爾也會將 VC++的實現與其他實現進行比較。

2 類布局

本節討論不同的繼承方式造成的不同記憶體布局。

2.1 C結構（struct）

由於C++基於C，所以C++也“基本上”相容C。特別地，C++規範在“結構”上使用了和C相同的，簡單的記憶體布局原則：成員變數按其被聲明的順序排列，按具體實現所規定的對齊原則在記憶體位址上對齊。 所有的C/C++廠商都保證他們的C/C++編譯器對於有效C結構採用完全相同的布局。這裡，A是一個簡單的C結構，其成員布局和對齊都一目瞭然

struct A { char c; int i; }; 

譯者註：從上圖可見，A在記憶體中佔有8個位元組，按照聲明成員的順序，前4個位元組包含一個字元（實際佔用1個位元組，3個位元組空著，補對齊），後4個位元組包含一個整數。A的指標就指向字元開始位元組處。

2.2 有C++特徵的C結構

當然了，C++不是複雜的C，C++本質上是物件導向的語言：包 含 繼承、封裝，以及多態 。原始的C結構經過改造，成了物件導向世界的基石——類。除了成員變數外，C++類還可以封裝成員函數和其他東西。然而，有趣的是，除非 為了實現虛函數和虛繼承引入的隱藏成員變數外，C++類執行個體的大小完全取決於一個類及其基類的成員變數。成員函數基本上不影響類執行個體的大小。

這裡提供的B是一個C結構，然而，該結構有一些C++特徵：控製成員可見度的“public/protected/private”關鍵字、成員函數、靜態成員，以及嵌套的型別宣告。雖然看著琳琅滿目，實際上，只有成員變數才佔用類執行個體的空間 。要注意的是，C++標準委員會不限制由“public/protected/private”關鍵字分開的各段在實現時的先後順序，因此，不同的編譯器實現的記憶體布局可能並不相同。（ 在VC++中，成員變數總是按照聲明時的順序排列）。

struct B { public: int bm1; protected: int bm2; private: int bm3; static int bsm; void bf(); static void bsf(); typedef void* bpv; struct N { }; }; 

譯者註：B中，為何static int bsm不佔用記憶體空間。因為它是靜態成員，該資料存放在程式的資料區段 中，不在類執行個體中。

2.3 單繼承

C++ 提供繼承的目的是在不同的類型之間提取共性。比如，科學家對物種進行分類，從而有種、屬、綱等說法。有了這種階層，我們才可能將某些具備特定性質的東西歸入到最合適的分類層次上，如“懷孩子的是哺乳動物”。由於這些屬性可以被子類繼承，所以，我們只要知道“鯨魚、人”是哺乳動物，就可以方便地指出“鯨魚、人都可以懷孩子”。那些特例，如鴨嘴獸（生蛋的哺乳動物），則要求我們對預設的屬性或行為進行覆蓋。
C++中的繼承文法很簡單，在子類後加上“:base”就可以了。下面的D繼承自基類C。

struct C { int c1; void cf(); }; 

struct D : C { int d1; void df(); }; 

既然衍生類別要保留基類的所有屬性和行為，自然地，每個衍生類別的執行個體都包含了一份完整的基類執行個體資料。在D中，並不是說基類C的資料一定要放在D的資料之前，只不過這樣放的話，能夠保證D中的C對象地址，恰好是D對象地址的第一個位元組。這種安排之下，有了衍生類別D的指標，要獲得基類C的指標，就不必要計算位移量 了。幾乎所有知名的C++廠商都採用這種記憶體安排（基類成員在前）。 在單繼承類層次下，每一個新的衍生類別都簡單地把自己的成員變數添加到基類的成員變數之後 。 看看上圖，C對象指標和D對象指標指向同一地址。

2.4 多重繼承

大多數情況下，其實單繼承就足夠了。但是，C++為了我們的方便，還提供了多重繼承。

比如，我們有一個組織模型，其中有經理類（分任務），工人類（幹活）。那麼，對於一線經理類，即既要從上級經理那裡領取任務幹活，又要向下級工人分任務的角色來說，如何在類層次中表達呢。單繼承在此就有點力不勝任。我們可以安排經理類先繼承工人類，一線經理類再繼承經理類，但這種階層錯誤地讓經理類繼承了工人類的屬性和行為。反之亦然。當然，一線經理類也可以僅僅從一個類（經理類或工人類）繼承，或者一個都不繼承，重新聲明一個或兩個介面，但這樣的實現弊處太多：多態不可能了；未能重用現有的介面；最嚴重的是，當介面變化時，必須多處維護。最合理的情況似乎是一線經理從兩個地方繼承屬性和行為——經理類、工人類。

C++就允許用多重繼承來解決這樣的問題：

struct Manager ... { ... }; struct Worker ... { ... }; struct MiddleManager : Manager, Worker { ... }; 

這樣的繼承將造成怎樣的類布局呢。下面我們還是用“字母類”來舉例：

struct E { int e1; void ef(); };

struct F : C, E { int f1; void ff(); };
結構F從C和E多重繼承得來。與單繼承相同的是，F執行個體拷貝了每個基類的所有資料。 與單繼承不同的是，在多重繼承下，內嵌的兩個基類的對象指標不可能全都與衍生類別對象指標相同：
F f; // (void*)&f == (void*)(C*)&f; // (void*)&f < (void*)(E*)&f; 
譯者註：上面那行說明C對象指標與F對象指標相同，下面那行說明E對象指標與F對象指標不同。

觀察類布局，可以看到F中內嵌的E對象，其指標與F指標並不相同。正如後文討論強制轉化和成員函數時指出的，這個位移量會造成少量的調用開銷。

具體的編譯器實現可以自由地選擇內嵌基類和衍生類別的布局。 VC++ 按照基類的聲明順序 先排列基類執行個體資料，最後才排列衍生類別資料。 當然，衍生類別資料本身也是按照聲明循序配置的（本規則並非一成不變 ，我們會看到，當一些基類有虛函數而另一些基類沒有時，記憶體布局並非如此）。

2.5 虛繼承

回到我們討論的一線經理類例子。讓我們考慮這種情況：如果經理類和工人類都繼承自“僱員類”，將會發生什麼。
struct Employee { ... }; struct Manager : Employee { ... }; struct Worker : Employee { ... }; struct MiddleManager : Manager, Worker { ... }; 
如果經理類和工人類都繼承自僱員類，很自然地，它們每個類都會從僱員類獲得一份資料拷貝。如 果不作特殊處理，一線經理類的執行個體將含有兩個 僱員類執行個體，它們分別來自兩個僱員基類 。 如果僱員類成員變數不多，問題不嚴重；如果成員變數眾多，則那份多餘的拷貝將造成執行個體產生時的嚴重開銷。更糟的是，這兩份不同的僱員執行個體可能分別被修改，造成資料的不一致。因此，我們需要讓經理類和工人類進行特殊的聲明，說明它們願意共用一份僱員基類執行個體資料。

很不幸，在C++中，這種“共用繼承”被稱為“虛繼承” ，把問題搞得似乎很抽象。虛繼承的文法很簡單，在指定基類時加上virtual關鍵字即可。
struct Employee { ... }; struct Manager : virtual Employee { ... }; struct Worker : virtual Employee { ... }; struct MiddleManager : Manager, Worker { ... };
使用虛繼承，比起單繼承和多重繼承有更大的實現開銷、調用開銷。回憶一下，在單繼承和多重繼承的情況下，內嵌的基類執行個體地址比起衍生類別執行個體地址來，要麼地址相同（單繼承，以及多重繼承的最靠左基類） ，要麼地址相差一個固定位移量（多重繼承的非最靠左基類） 。 然而，當虛繼承時，一般說來，衍生類別地址和其虛基類地址之間的位移量是不固定的，因為如果這個衍生類別又被進一步繼承的話，最終衍生類別會把共用的虛基類執行個體資料放到一個與上一層衍生類別不同的位移量處。 請看下例：


struct G : virtual C { int g1; void gf(); };
譯者註：GdGvbptrG（In G, the displacement of G’s virtual base pointer to G）意思是：在G中，G對象的指標與G的虛基類表指標之間的位移量，在此可見為0，因為G對象記憶體布局第一項就是虛基類表指標； GdGvbptrC（In G, the displacement of G’s virtual base pointer to C）意思是：在G中，C對象的指標與G的虛基類表指標之間的位移量，在此可見為8。

  struct H : virtual C { int h1; void hf(); };

struct I : G, H { int i1; void _if(); };暫時不追究vbptr成員變數從何而來。從上面這些圖可以直觀地看到，在G對象中，內嵌的C基類對象的資料緊跟在G的資料之後，在H對象中，內嵌的C基類對象的資料也緊跟在H的資料之後。但是，在I對象中，記憶體布局就並非如此了。VC++實現的記憶體布局中，G對象執行個體中G對象和C對象之間的位移，不同於I對象執行個體中G對象和C對象之間的位移。當使用指標訪問虛基類成員變數時，由於指標可以是指向衍生類別執行個體的基類指標，所以，編譯器不能根據聲明的指標類型計算位移，而必須找到另一種間接的方法，從衍生類別指標計算虛基類的位置。
在VC++ 中，對每個繼承自虛基類的類執行個體，將增加一個隱藏的“虛基類表指標”（vbptr） 成員變數，從而達到間接計算虛基類位置的目的。該變數指向一個全類共用的位移量表，表中項目記錄了對於該類 而言，“虛基類表指標”與虛基類之間的位移量。
其它的實現方式中，有一種是在衍生類別中使用指標成員變數。這些指標成員變數指向衍生類別的虛基類，每個虛基類一個指標。這種方式的優點是：擷取虛基類地址時，所用代碼比較少。然而，編譯器最佳化代碼時通常都可以採取措施避免重複計算虛基類地址。況且，這種實現方式還有一個大弊端：從多個虛基類派生時，類執行個體將佔用更多的記憶體空間；擷取虛基類的虛基類的地址時，需要多次使用指標，從而效率較低等等。

在VC++中，G擁有一個隱藏的“虛基類表指標”成員，指向一個虛基類表，該表的第二項是G dGvbptrC。（在G中，虛基類對象C的地址與G的“虛基類表指標”之間的位移量 （ 當對於所有的衍生類別來說位移量不變時，省略“d”前的首碼））。比如，在32位平台上，GdGvptrC是8個位元組。同樣，在I執行個體中的G對象執行個體也有 “虛基類表指標”，不過該指標指向一個適用於“G處於I之中” 的虛基類表，表中一項為IdGvbptrC，值為20。

觀察前面的G、H和I， 我們可以得到如下關於VC++虛繼承下記憶體布局的結論：
1 首先排列非虛繼承的基類執行個體；
2 有虛基類時，為每個基類增加一個隱藏的vbptr，除非已經從非虛繼承的類那裡繼承了一個vbptr；
3 排列衍生類別的新資料成員；
4 在執行個體最後，排列每個虛基類的一個執行個體。

該布局安排使得虛基類的位置隨著衍生類別的不同而“浮動不定”，但是，非虛基類因此也就湊在一起，彼此的位移量固定不變。

3 成員變數

介紹了類布局之後，我們接著考慮對不同的繼承方式，訪問成員變數的開銷究竟如何。

沒有繼承： 沒有任何繼承關係時，訪問成員變數和C語言的情況完全一樣：從指向對象的指標，考慮一定的位移量即可。
C* pc; pc->c1; // *(pc + dCc1); 
譯者註：pc是指向C的指標。
a. 訪問C的成員變數c1，只需要在pc上加上固定的位移量dCc1（在C中，C指標地址與其c1成員變數之間的位移量值），再擷取該指標的內容即可。

單繼承： 由於衍生類別執行個體與其基類執行個體之間的位移量是常數0，所以，可以直接利用基類指標和基類成員之間的位移量關係，如此計算得以簡化。
D* pd; pd->c1; // *(pd + dDC + dCc1); // *(pd + dDc1); pd->d1; // *(pd + dDd1); 
譯者註：D從C單繼承，pd為指向D的指標。
a. 當訪問基類成員c1時，計算步驟本來應該為“pd+dDC+dCc1”，即為先計算D對象和C對象之間的位移，再在此基礎上加上C對象指標與成員變數c1 之間的位移量。然而，由於dDC恒定為0，所以直接計算C對象地址與c1之間的位移就可以了。
b. 當訪問衍生類別成員d1時，直接計算位移量。

多重繼承 ：雖然衍生類別與某個基類之間的位移量可能不為0，然而，該位移量總是一個常數。只要是個常數，訪問成員變數，導出成員變數位移時的計算就可以被簡化。可見即使對於多重繼承來說，訪問成員變數開銷仍然不大。
F* pf; pf->c1; // *(pf + dFC + dCc1); // *(pf + dFc1); pf->e1; // *(pf + dFE + dEe1); // *(pf + dFe1); pf->f1; // *(pf + dFf1); 
譯者註：F繼承自C和E，pf是指向F對象的指標。
a. 訪問C類成員c1時，F對象與內嵌C對象的相對位移為0，可以直接計算F和c1的位移；
b. 訪問E類成員e1時，F對象與內嵌E對象的相對位移是一個常數，F和e1之間的位移計算也可以被簡化；
c. 訪問F自己的成員f1時，直接計算位移量。

虛繼承： 當類有虛基類時，訪問非虛基類的成員仍然是計算固定位移量的問題。然而，訪問虛基類的成員變數，開銷就增大了 ， 因為必須經過如下步驟才能獲得成員變數的地址：
1. 擷取“虛基類表指標”；
2. 擷取虛基類表中某一表項的內容；
3. 把內容中指出的位移量加到“虛基類表指標”的地址上。

然而，事情並非永遠如此。正如下面訪問I對象的c1成員那樣，如果不是通過指標訪問，而是直接通過對象執行個體，則衍生類別的布局可以在編譯期間靜態獲得，位移量也可以在編譯時間計算，因此也就不必要根據虛基類表的表項來間接計算了。
I* pi; pi->c1; // *(pi + dIGvbptr + (*(pi+dIGvbptr))[1] + dCc1); pi->g1; // *(pi + dIG + dGg1); // *(pi + dIg1); pi->h1; // *(pi + dIH + dHh1); // *(pi + dIh1); pi->i1; // *(pi + dIi1); I i; i.c1; // *(&i + IdIC + dCc1); // *(&i + IdIc1);
譯者註：I繼承自G和H，G和H的虛基類是C，pi是指向I對象的指標。
a. 訪問虛基類C的成員c1時，dIGvbptr是“在I中，I對象指標與G的“虛基類表指標”之間的位移”，*(pi + dIGvbptr)是虛基類表的開始地址，*(pi + dIGvbptr)[1]是虛基類表的第二項的內容（在I對象中，G對象的“虛基類表指標”與虛基類之間的位移），dCc1是C對象指標與成員變數c1之間的位移；
b. 訪問非虛基類G的成員g1時，直接計算位移量；
c. 訪問非虛基類H的成員h1時，直接計算位移量；
d. 訪問自身成員i1時，直接使用位移量；
e. 當聲明了一個對象執行個體，用點“.”操作符訪問虛基類成員c1時，由於編譯時間就完全知道對象的布局情況，所以可以直接計算位移量。

當訪問類繼承層次中，多層虛基類的成員變數時，情況又如何呢。比如，訪問虛基類的虛基類的成員變數時。一些實現方式為：儲存一個指向直接虛基類的指標，然後就可以從直接虛基類找到它的虛基類，逐級上推。VC++最佳化了這個過程。VC++在虛基類表中增加了一些額外的項，這些項儲存了從衍生類別到其各層虛基類的位移量。

4 強制轉化

如果沒有虛基類的問題，將一個指標強制轉化為另一個類型的指標代價並不高昂。如果在要求轉化的兩個指標之間有“基類-衍生類別”關係，編譯器只需要簡單地在兩者之間加上或者減去一個位移量即可（並且該量還往往為0）。
F* pf; (C*)pf; // (C*)(pf ? pf + dFC : 0); // (C*)pf; (E*)pf; // (E*)(pf ? pf + dFE : 0);

C和E是F的基類，將F的指標pf轉化為C*或E*，只需要將pf加上一個相應的位移量。轉化為C類型指標C*時，不需要計算，因為F和C之間的位移量為 0。轉化為E類型指標E*時，必須在指標上加一個非0的位移常量dFE。C ++規範要求NULL指標在強制轉化後依然為NULL ，因此在做強制轉化需要的運算之前，VC++會檢查指標是否為NULL。當然，這個檢查只有當指標被顯示或者隱式轉化為相互關聯類型指標時才進行；當在衍生類別對象中調用基類的方法，從而衍生類別指標在後台被轉化為一個基類的Const “this” 指標時，這個檢查就不需要進行了，因為在此時，該指標一定不為NULL。

正如你猜想的，當繼承關係中存在虛基類時，強制轉化的開銷會比較大。具體說來，和訪問虛基類成員變數的開銷相當。
I* pi; (G*)pi; // (G*)pi; (H*)pi; // (H*)(pi ? pi + dIH : 0); (C*)pi; // (C*)(pi ? (pi+dIGvbptr + (*(pi+dIGvbptr))[1]) : 0);
譯者註：pi是指向I對象的指標，G,H是I的基類，C是G,H的虛基類。
a. 強制轉化pi為G*時，由於G*和I*的地址相同，不需要計算；
b. 強制轉化pi為H*時，只需要考慮一個常量位移；
c. 強制轉化pi為C*時，所作的計算和訪問虛基類成員變數的開銷相同，首先得到G的虛基類表指標，再從虛基類表的第二項中取出G到虛基類C的位移量，最後根據pi、虛基類表位移和虛基類C與虛基類表指標之間的位移計算出C*。

一般說來，當從衍生類別中訪問虛基類成員時，應該先強制轉化衍生類別指標為虛基類指標，然後一直使用虛基類指標來訪問虛基類成員變數。這樣做，可以避免每次都要計算虛基類地址的開銷。 見下例。

/* before: */             ... pi->c1 ... pi->c1 ...
/* faster: */ C* pc = pi; ... pc->c1 ... pc->c1 ...
譯者註：前者一直使用衍生類別指標pi，故每次訪問c1都有計算虛基類地址的較大開銷；後者先將pi轉化為虛基類指標pc，故後續調用可以省去計算虛基類地址的開銷。

 

5 成員函數

 

一個C++成員函數只是類範圍內的又一個成員。X類每一個非靜態成員函數都會接受一個特殊的隱藏參數——this指標，類型為X* const。 該指標在後台初始化為指向成員函數工作於其上的對象。同樣，在成員函數體內，成員變數的訪問是通過在後台計算與this指標的位移來進行。

struct P { int p1; void pf(); // new virtual void pvf(); // new };

P有一個非虛成員函數pf()，以及一個虛成員函數pvf()。很明顯，虛成員函數造成對象執行個體佔用更多記憶體空間，因為虛成員函數需要虛函數表指標。這一點以後還會談到。這裡要特別指出的是，聲明非虛成員函數不會造成任何對象執行個體的記憶體開銷。現在，考慮P::pf()的定義。
void P::pf() { // void P::pf([P *const this]) ++p1; // ++(this->p1); }

 

這裡P:pf()接受了一個隱藏的this指標參數 ，對於每個成員函數調用，編譯器都會自動加上這個參數。同時，注意成員變數訪問也許比看起來要代價高昂一些，因為成員變數訪問通過this指標進行，在有的繼承層次下，this指標需要調整，所以訪問的開銷可能會比較大。然而，從另一方面來說，編譯器通常會把this指標緩衝到寄存器中，所以，成員變數訪問的代價不會比訪問局部變數的效率更差。
譯者註：訪問局部變數，需要到SP寄存器中得到棧指標，再加上局部變數與棧頂的位移。在沒有虛基類的情況下，如果編譯器把this指標緩衝到了寄存器中，訪問成員變數的過程將與訪問局部變數的開銷相似。

5.1 覆蓋成員函數

和成員變數一樣，成員函數也會被繼承。與成員變數不同的是，通過在衍生類別中重新定義基類函數，一個衍生類別可以覆蓋，或者說替換掉基類的函數定義。覆蓋是靜態 （根據成員函數的靜態類型在編譯時間決定）還是動態 （通過對象指標在運行時動態決定），依賴於成員函數是否被聲明為“虛函數”。

Q從P繼承了成員變數和成員函數。Q聲明了pf()，覆蓋了P::pf()。Q還聲明了pvf()，覆蓋了P::pvf()虛函數。Q還聲明了新的非虛成員函數qf()，以及新的虛成員函數qvf()。

 

struct Q : P { int q1; void pf(); // overrides P::pf void qf(); // new void pvf(); // overrides P::pvf virtual void qvf(); // new };
對於非虛 的成員函數來說，調用哪個成員函數是在編譯 時，根據“->”操作符左邊指標運算式的類型靜態決定 的。特別地，即使ppq指向Q的執行個體，ppq->pf()仍然調用的是P::pf()，因為ppq被聲明為“P*”。（注意，“->”操作符左邊的指標類型決定隱藏的this參數的類型。）
P p; P* pp = &p; Q q; P* ppq = &q; Q* pq = &q; pp->pf(); // pp->P::pf(); // P::pf(pp); ppq->pf(); // ppq->P::pf(); // P::pf(ppq); pq->pf(); // pq->Q::pf(); // Q::pf((P*)pq); （錯誤!） pq->qf(); // pq->Q::qf(); // Q::qf(pq);
譯者註：標記“錯誤”處，P*似應為Q*。因為pf非虛函數，而pq的類型為Q*，故應該調用到Q的pf函數上，從而該函數應該要求一個Q* const類型的this指標。

對於虛函數 調用來說，調用哪個成員函數在運行時 決定。不管“->”操作符左邊的指標運算式的類型如何，調用的虛函數都是由指標實際指向的執行個體類型所決定 。比如，儘管ppq的類型是P*，當ppq指向Q的執行個體時，調用的仍然是Q::pvf()。
pp->pvf(); // pp->P::pvf(); // P::pvf(pp); ppq->pvf(); // ppq->Q::pvf(); // Q::pvf((Q*)ppq); pq->pvf(); // pq->Q::pvf(); // Q::pvf((P*)pq); （錯誤。）
譯者註：標記“錯誤”處，P*似應為Q*。因為pvf是虛函數，pq本來就是Q*，又指向Q的執行個體，從哪個方面來看都不應該是P*。

 

為了實現這種機制，引入了隱藏的vfptr 成員變數。 一個vfptr被加入到類中（如果類中沒有的話），該vfptr指向類的虛函數表（vftable）。類中每個虛函數在該類的虛函數表中都佔據一項。每項儲存一個對於該類適用的虛函數的地址。因此，調用虛函數的過程如下：取得執行個體的vfptr；通過vfptr得到虛函數表的一項；通過虛函數表該項的函數地址間接調用虛函數。 也就是說，在普通函數調用的參數傳遞、調用、返回指令開銷外，虛函數調用還需要額外的開銷。

 

回頭再看看P和Q的記憶體布局，可以發現，VC++編譯器把隱藏的vfptr成員變數放在P和Q執行個體的開始處。這就使虛函數的調用能夠盡量快一些。實際上，VC++的實現方式是，保證任何有虛函數的類的第一項永遠是vfptr。 這就可能要求在執行個體布局時，在基類前插入新的vfptr，或者要求在多重繼承時，雖然在右邊，然而有vfptr的基類放到左邊沒有vfptr的基類的前面（如下）。
class CA { int a;}; class CB { int b;}; class CL : public CB, public CA { int c;};
對於CL類，它的記憶體布局是：
int b;
int a;
int c;
但是，改造CA如下：
class CA { int a; virtual void seta( int _a ) { a = _a; } };
對於同樣繼承順序的CL，記憶體布局是：
vfptr;
int a;
int b;
int c;

許多C++的實現會共用或者重用從基類繼承來的vfptr。比如，Q並不會有一個額外的vfptr，指向一個專門存放新的虛函數qvf()的虛函數表。Qvf項只是簡單地追加 到P的虛函數表的末尾。如此一來，單繼承的代價就不算高昂。一旦一個執行個體有vfptr了，它就不需要更多的vfptr。新的衍生類別可以引入更多的虛函數，這些新的虛函數只是簡單地在已存在的，“每類一個”的虛函數表的末尾追加新項。

5.2 多重繼承下的虛函數

如果從多個有虛函數的基類繼承，一個執行個體就有可能包含多個vfptr。考慮如下的R和S類：

struct R { int r1; virtual void pvf(); // new virtual void rvf(); // new };

struct S : P, R { int s1; void pvf(); // overrides P::pvf and R::pvf void rvf(); // overrides R::rvf void svf(); // new };

這裡R是另一個包含虛函數的類。因為S從P和R多重繼承，S的執行個體內嵌P和R的執行個體，以及S自身的資料成員S::s1。注意，在多重繼承下，靠右的基類R，其執行個體的地址和P與S不同。 S::pvf覆蓋了P::pvf()和R::pvf()，S::rvf()覆蓋了R::rvf()。
S s; S* ps = &s; ((P*)ps)->pvf(); // (*(P*)ps)->P::vfptr[0])((S*)(P*)ps) ((R*)ps)->pvf(); // (*(R*)ps)->R::vfptr[0])((S*)(R*)ps) ps->pvf(); // one of the above; calls S::pvf()
譯者註：
調用((P*)ps)->pvf()時，先到P的虛函數表中取出第一項，然後把ps轉化為S*作為this指標傳遞進去；
調用((R*)ps)->pvf()時，先到R的虛函數表中取出第一項，然後把ps轉化為S*作為this指標傳遞進去；

因為S::pvf()覆蓋了P::pvf()和R::pvf()，在S的虛函數表中，相應的項也應該被覆蓋。然而，我們很快注意到，不光可以用P*，還可以用R*來調用pvf()。問題出現了：R的地址與P和S的地址不同。運算式(R*)ps與運算式(P*)ps指向類布局中不同的位置。因為函數S::pvf希望獲得一個S*作為隱藏的this指標參數，虛函數必須把R*轉化為S*。因此，在S對R虛函數表的拷貝中，pvf函數對應的項，指向的是一個“調整塊 ”的地址，該調整塊使用必要的計算，把R*轉換為需要的S*。
譯者註：這就是“thunk1: this-= sdPR; goto S::pvf”乾的事。先根據P和R在S中的位移，調整this為P*，也就是S*，然後跳轉到相應的虛函數處執行。

在微軟VC++實現中，對於有虛函數的多重繼承，只有當衍生類別虛函數覆蓋了多個基類的虛函數時，才使用調整塊。  

5.3 地址點與“邏輯this調整”

考慮下一個虛函數S::rvf()，該函數覆蓋了R::rvf()。我們都知道S::rvf()必須有一個隱藏的S*類型的this參數。但是，因為也可以用R*來調用rvf()，也就是說，R的rvf虛函數槽可能以如下方式被用到：
((R*)ps)->rvf(); // (*((R*)ps)->R::vfptr[1])((R*)ps)所以，大多數實現用另一個調整塊將傳遞給rvf的R*轉換為S*。還有一些實現在S的虛函數表末尾添加一個特別的虛函數項，該虛函數項提供方法，從而可以直接調用ps->rvf()，而不用先轉換R*。MSC++的實現不是這樣，MSC++有意將S::rvf編譯為接受一個指向S中嵌套的R執行個體，而非指向S執行個體的指標（我們稱這種行為是“給衍生類別的指標類型與該虛函數第一次被引入時接受的指標類型相同”）。所有這些在後台透明發生，對成員變數的存取，成員函數的this指標，都進行“邏輯this調整”。

當然，在debugger中，必須對這種this調整進行補償。
ps->rvf(); // ((R*)ps)->rvf(); // S::rvf((R*)ps)譯者註：調用rvf虛函數時，直接給入R*作為this指標。

所以，當覆蓋非最左邊的基類的虛函數時，MSC++一般不建立調整塊，也不增加額外的虛函數項。

5.4 調整塊

正如已經描述的，有時需要調整塊來調整this指標的值（this指標通常位於棧上返回地址之下，或者在寄存器中），在this指標上加或減去一個常量位移，再調用虛函數。某些實現（尤其是基於cfront的）並不使用調整塊機制。它們在每個虛函數表項中增加額外的位移資料。每當虛函數被調用時，該位移資料（通常為0）,被加到對象的地址上，然後對象的地址再作為this指標傳入。

ps->rvf(); // struct { void (*pfn)(void*); size_t disp; }; // (*ps->vfptr[i].pfn)(ps + ps->vfptr[i].disp);譯者註：當調用rvf虛函數時，前一句表示虛函數表每一項是一個結構，結構中包含位移量；後一句表示調用第i個虛函數時，this指標使用儲存在虛函數表中第i項的位移量來進行調整。

這種方法的缺點是虛函數表增大了，虛函數的調用也更加複雜。

現代基於PC的實現一般採用“調整—跳轉”技術：
S::pvf-adjust: // MSC++ this -= SdPR; goto S::pvf()當然，下面的代碼序列更好（然而，當前沒有任何實現採用該方法）：
S::pvf-adjust: this -= SdPR; // fall into S::pvf() S::pvf() { ... }譯者註：IBM的C++編譯器使用該方法。

5.5 虛繼承下的虛函數

T虛繼承P，覆蓋P的虛成員函數，聲明了新的虛函數。如果採用在基類虛函數表末尾添加新項的方式，則訪問虛函數總要求訪問虛基類。在VC++中，為了避免擷取虛函數表時，轉換到虛基類P的高昂代價，T中的新虛函數通過一個新的虛函數表 擷取 ，從而帶來了一個新的虛函數表指標。該指標放在T執行個體的頂端。

struct T : virtual P { int t1; void pvf(); // overrides P::pvf virtual void tvf(); // new }; void T::pvf() { ++p1; // ((P*)this)->p1++; // vbtable lookup! ++t1; // this->t1++; }
如上所示，即使是在虛函數中，訪問虛基類的成員變數也要通過擷取虛基類表的位移，實行計算來進行。這樣做之所以必要，是因為虛函數可能被進一步繼承的類所覆蓋，而進一步繼承的類的布局中，虛基類的位置變化了。 下面就是這樣的一個類：

struct U : T { int u1; };

在此U增加了一個成員變數，從而改變了P的位移。因為VC++實現中，T::pvf()接受的是嵌套在T中的P的指標，所以，需要提供一個調整塊，把this指標調整到T::t1之後（該處即是P在T中的位置）。