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結構，其成員布局和對齊都一目瞭然

view plain copy to clipboard print ? struct  A {      char  c;      int  i;   };   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++中，成員變數總是按照聲明時的順序排列）。

view plain copy to clipboard print ? struct  B {   public :      int  bm1;   protected :      int  bm2;   private :      int  bm3;      static   int  bsm;      void  bf();      static   void  bsf();      typedef   void * bpv;      struct  N { };   };   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。

view plain copy to clipboard print ? struct  C {      int  c1;      void  cf();   };   struct C { int c1; void cf(); };  

view plain copy to clipboard print ? struct  D : C {      int  d1;      void  df();   };   struct D : C { int d1; void df(); };  

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

2.4 多重繼承

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

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

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

view plain copy to clipboard print ? struct  Manager ... { ... };   struct  Worker ... { ... };   struct  MiddleManager : Manager, Worker { ... };   struct Manager ... { ... }; struct Worker ... { ... }; struct MiddleManager : Manager, Worker { ... };  

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

view plain copy to clipboard print ? struct  E {      int  e1;      void  ef();   };   struct E { int e1; void ef(); };

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

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

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

2.5 虛繼承

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

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


view plain copy to clipboard print ? struct  G :  virtual  C {      int  g1;      void  gf();   };   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。

  view plain copy to clipboard print ? struct  H :  virtual  C {      int  h1;      void  hf();   };   struct H : virtual C { int h1; void hf(); };

view plain copy to clipboard print ? struct  I : G, H {      int  i1;      void  _if();   };   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語言的情況完全一樣：從指向對象的指標，考慮一定的位移量即可。
view plain copy to clipboard print ? C* pc;   pc->c1; // *(pc + dCc1);    C* pc; pc->c1; // *(pc + dCc1);  
譯者註：pc是指向C的指標。
a. 訪問C的成員變數c1，只需要在pc上加上固定的位移量dCc1（在C中，C指標地址與其c1成員變數之間的位移量值），再擷取該指標的內容即可。

單繼承： 由於衍生類別執行個體與其基類執行個體之間的位移量是常數0，所以，可以直接利用基類指標和基類成員之間的位移量關係，如此計算得以簡化。
view plain copy to clipboard print ? D* pd;   pd->c1; // *(pd + dDC + dCc1); // *(pd + dDc1);    pd->d1; // *(pd + dDd1);    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，然而，該位移量總是一個常數。只要是個常數，訪問成員變數，導出成員變數位移時的計算就可以被簡化。可見即使對於多重繼承來說，訪問成員變數開銷仍然不大。
view plain copy to clipboard