C++對象模型在內存中的實現

1、C+對象模型在內存中的實現 -基于微軟VC+分析（Visual Studio 2010）jhanker（蔣李軍） jhanker 2016-04-26相關C+對象模型深入了解的文章在互聯(lián)網上有很多版本。要么排版不清晰，要么缺少圖示，嚴重的影響閱讀效果！現對每一段代碼的圖示都增加了VC+2010環(huán)境下編譯器輸出的類的對象模型圖（文中黑色背景的圖），通過對網上一些有用的相關資料的整合，讓讀者能更加直觀理解其本質。本文的篇幅較長，但還是希望您能慢慢的品讀，如果有不理解的地方可以先看后面的附錄，閱讀的過程中可以邊閱讀邊調試附錄中的調試代碼，相信通過仔細的調試，分析，理解，您將會對C+有更深層次的理解！

2、 一個C+程序員，想要進一步提升技術水平的話，應該多了解一些語言的細節(jié)。對于使用VC+的程序員來說，還應該了解一些VC+對于C+的詮釋。本文是深入理解C+對象模型比較好的一個出發(fā)點。了解你所使用的編程語言究竟是如何實現的，對于C+程序員可能特別有意義。首先，它可以去除我們對于所使用語言的神秘感，使我們不至于對于編譯器干的活感到完全不可思議；尤其重要的是，它使我們在Debug和使用語言高級特性的時候，有更多的把握。當需要提高代碼效率的時候，這些知識也能夠很好地幫助我們。 對每個語言特性，我們將簡要介紹該特性背后的動機，當然，本文決不是“C+入門”，大家對此要有充分認識，以及該特性在微軟的 VC+

3、中是如何實現的。這里要注意區(qū)分抽象的C+語言與其特定實現。微軟之外的其他C+廠商可能提供一個完全不同的實現，我們偶爾也會將 VC+的實現與其他實現進行比較。 首先，我們順次考察類，單繼承，多重繼承，以及虛繼承的布局； 接著，我們講成員變量和成員函數的訪問已經訪問時的開銷情況，當然，這里面包含虛函數的情況；再接下來，我們考察構造函數，析構函數，以及特殊的賦值操作符成員函數是如何工作的，數組是如何動態(tài)構造和銷毀的；最后，簡單地介紹對異常處理的支持。 1、類（class）布局 本節(jié)討論不同的繼承方式造成的不同內存布局。 1.1 類的存儲結構 由于C+基于C，所以C+也“基本上”兼容C。特別地，C+規(guī)

4、范在“類”上使用了和C“結構”相同的，簡單的內存布局原則：成員變量按其被聲明的順序排列，按具體實現所規(guī)定的對齊原則在內存地址上對齊。所有的C/C+廠商都保證他們的C/C+編譯器對于有效的C結構采用完全相同的布局。這里，A是一個簡單的類，其成員布局和對齊方式都一目了然1 class A 2 public:3 char c;4 int i;5 ;（圖1）從上圖(左)可見，A在內存中占有8個字節(jié)，按照聲明成員的順序，前4個字節(jié)包含一個字符（實際占用1個字節(jié)，3個字節(jié)空著，補對齊），后4個字節(jié)包含一個整數。A的指針就指向字符開始字節(jié)處。上圖(右)為Visual

5、Studio 2010 編譯后在輸出窗口中顯示的內存分布情況。(項目屬性配置屬性C/C+命令行其他選項中添加選項“/d1reportAllClassLayout”。再次編譯時候，編譯器會輸出所有定義類的對象模型。由于輸出的信息過多，我們可以使用“Ctrl+F”查找命令，找到對象模型的輸出。)需要說明的是右圖的 0 ,4 是相對字符開始地址的偏移地址。當然了，C+不是復雜的C，C+本質上是面向對象的語言：包含 繼承、封裝，以及多態(tài) 。原始的C結構經過改造，成了面向對象世界的基石類。除了成員變量外，C+類還可以封裝成員函數和其他東西。然而，有趣的是，除非為了實現虛函數和虛繼承引入的隱藏成員變量外，

6、C+類實例的大小完全取決于一個類及其基類的成員變量！成員函數基本上不影響類實例的大小。這里提供的B是有更多C+特征的類：控制成員可見性的“public/protected/private”關鍵字、成員函數、靜態(tài)成員，以及嵌套的類型聲明。雖然看著琳瑯滿目，實際上，只有成員變量才占用類實例的空間。有一點要注意的是，C+標準委員會不限制由“public/protected/private”關鍵字分開的各段在實現時的先后順序，因此，不同的編譯器實現的內存布局可能并不相同。（ 在VC+中，成員變量總是按照聲明時的順序排列）。1 class B 2 public:  

7、;3  int bm1;  4protected:  5 int bm2;  6private:  7 int bm3;  8 static int bsm;  9 void bf();  10 static void bsf();  11 typedef  void*

8、  bpv;  12 struct N    13;struct B public: int bm1;protected: int bm2;private: int bm3; static int bsm; void bf(); static void bsf(); typedef void* bpv; struct N ;  （圖2） B中，為何static int bsm不占用內存空間？因為它是靜態(tài)成員，該數據存放在程序的靜態(tài)數據段中，不在類實例中。（相關內存區(qū)域劃分知識，見附1.） 1.2

9、 單繼承 C+ 提供繼承的目的是在不同的類型之間提取共性。比如，科學家對物種進行分類，從而有種、屬、綱等說法。有了這種層次結構，我們才可能將某些具備特定性質的東西歸入到最合適的分類層次上，如“懷孩子的是哺乳動物”。由于這些屬性可以被子類繼承，所以，我們只要知道“鯨魚、人”是哺乳動物，就可以方便地指出“鯨魚、人都可以懷孩子”。那些特例，如鴨嘴獸（生蛋的哺乳動物），則要求我們對缺省的屬性或行為進行覆蓋。C+中的繼承語法很簡單，在子類后加上“: public基類名（base）”就可以了。（附2. C+之繼承與派生）下面的D繼承自基類C。(本文全部的調試代碼見附4.) 1 class C&#

10、160;   /類C2 public:  3int c1;   /類C的成員變量4void cf();   /類C的成員函數5;  struct C int c1; void cf();  （圖3）1 class D :  public C  /類D，繼承類C  2 public:  3int d1;  /類D的成員變量 4void df(); &

11、#160;/類D的成員函數 5;  struct D : C int d1; void df();  （圖4） 既然派生類要保留基類的所有屬性和行為，自然地，每個派生類的實例都包含了一份完整的基類實例數據。在D中，并不是說基類C的數據一定要放在D的數據之前，只不過這樣放的話，能夠保證D中的C對象地址，恰好是D對象地址的第一個字節(jié)。這種安排之下，有了派生類D的指針，要獲得基類C的指針，就不必要計算偏移量了。幾乎所有知名的C+廠商都采用這種內存安排（基類成員在前）。在單繼承類層次下，每一個新的派生類都簡單地把自己的成員變量添加到基類的成員變量之后 ?？纯瓷蠄D

12、，C對象指針和D對象指針指向同一地址。 ( 上圖(右)base class C, class D 的框架結構的起始的上邊界“+-”重合形象的說明C對象指針和D對象指針指向同一地址)1.3 多重繼承 大多數情況下，其實單繼承就足夠了。但是，C+為了我們的方便，還提供了多重繼承。 比如，我們有一個組織模型，其中有經理類（分任務），工人類（干活）。那么，對于一線經理類，即既要從上級經理那里領取任務干活，又要向下級工人分任務，這樣的角色，如何在類層次中表達呢？單繼承在此就有點力不從心。我們可以安排經理類先繼承工人類，一線經理類再繼承經理類，但這種層次結構錯誤地讓經理類繼承了工人類的屬性和行為。反之亦然

13、。當然，一線經理類也可以僅僅從一個類（經理類或工人類）繼承，或者一個都不繼承，重新聲明一個或兩個接口（函數），但這樣的實現弊處太多：多態(tài)不可能了-未能重用現有的接口（函數）；最嚴重的是，當接口（函數）變化時，必須多處維護。最合理的情況似乎是一線經理從兩個地方繼承屬性和行為經理類、工人類。C+就允許用多重繼承來解決這樣的問題： 1class Manager .  .    /經理類2class Worker .  .    /工人類3class M

14、iddleManager : Manager, Worker  .   /一線經理類struct Manager . . ;struct Worker . . ;struct MiddleManager : Manager, Worker . ;  這樣的繼承將造成怎樣的類布局呢？下面我們還是用“字母”類來舉例： 1 class E   2 public:   3int e1;   4void ef();

15、  5;  （圖5）struct E int e1; void ef();1 class F : public C, public E   2 public:   3int f1;   4void ff();   5;  （圖6）struct F : C, E int f1; void ff(); 類F從C和E多重繼承得來。與單繼承相同的是，F實例拷貝了每個基類的所有數據。與單繼承不同的

16、是，在多重繼承下，內嵌的兩個基類的對象指針不可能全都與派生類對象指針相同：1F f;   2/ (void*)&f = (void*)(C*)&f;   /說明C對象指針與F對象指針相同3/ (void*)&f < (void*)(E*)&f;  /說明E對象指針與F對象指針不同4 /且基類E的地址比子類F的地址數值大F f;/ (void*)&f = (void*)(C*)&f;/ (void*)&f

17、< (void*)(E*)&f;  觀察類布局，可以看到F中內嵌的E對象，其指針與F指針并不相同。正如后文討論強制轉化和成員函數時指出的，這個偏移量會造成少量的調用開銷。具體的編譯器實現可以自由地選擇內嵌基類和派生類的布局。VC+ 按照基類的聲明順序先排列基類實例數據，最后才排列派生類數據。 當然，派生類數據本身也是按照聲明順序布局的（本規(guī)則并非一成不變，現在你可以不要在腦海中糾結排序的問題，因為閱讀到后文我們會看到，當一些基類有虛函數而另一些基類沒有時，內存布局并非如此）。 1.4 虛繼承 回到我們討論的一線經理類例子。讓我們考慮這種情況：如果經理類和工人類都繼承自“

18、雇員類”，將會發(fā)生什么？1class Employee  .    /雇員類2class Manager : public Employee  .    /經理類3class Worker : public Employee  .    /工人類4class MiddleManager : public Manager, public W

19、orker  .  /一線經理類 struct Employee . ;struct Manager : Employee . ;struct Worker : Employee . ;struct MiddleManager : Manager, Worker . ;  如果經理類和工人類都繼承自雇員類，很自然地，它們每個類都會從雇員類獲得一份數據拷貝。如果不作特殊處理，一線經理類的實例將含有兩個雇員類實例，它們分別來自兩個雇員基類 。如果雇員類成員變量不多，問題不嚴重；如果雇員類成員變量眾多，則那份多余的拷貝將造成實例生成時的嚴重

20、開銷。更糟的是，這兩份不同的雇員實例可能分別被修改，造成數據的不一致。因此，我們需要讓經理類和工人類進行特殊的聲明，說明它們愿意共享一份雇員基類實例數據。 很不幸，在C+中，這種“共享繼承”被稱為“虛繼承”，把問題搞得似乎很抽象，但不要擔心，其實虛繼承的語法很簡單，在指定基類時加上virtual關鍵字即可。把上面的繼承關系改成虛繼承，代碼如下：1class Employee  .    2class Manager : virtual public Employee  .&#

21、160;   3class Worker : virtual public Employee  .    4class MiddleManager : public Manager, public Worker  .   struct Employee . ;struct Manager : virtual Employee . ;struct Worker : virtual Employee

22、. ;struct MiddleManager : Manager, Worker . ;使用虛繼承，比起單繼承和多重繼承有更大的實現開銷、調用開銷?；貞浺幌拢趩卫^承和多重繼承的情況下，內嵌的基類實例地址比起派生類實例地址來，要么地址相同（單繼承，以及多重繼承的最靠左基的類） ，要么地址相差一個固定偏移量（多重繼承的非最靠左的基類） 。 然而，當虛繼承時，一般說來，派生類地址和其虛基類地址之間的偏移量是不固定的，因為如果這個派生類又被進一步繼承的話，最終派生類會把共享的虛基類實例數據放到一個與上一層派生類不同的偏移量處。 請看下面的實例,請大家仔細觀察虛基類在派生類中的位置，至于其他的內容，

23、如vbptr成員變量從何而來？什么作用？GdGvbptrG，GdGvbptrC，vbtable等是什么東東？干什么用的？為什么要有這樣的設計？暫時都不要追究，后面會詳細解釋： 1 class G : virtual public C  2 public:    3int g1;   4void gf();   5;  （圖7）struct G : virtual C int g1; void gf();與上述的G一樣

24、建立一個H，也虛繼承C，代碼和內存分布見下圖：1 class H : virtual  public C    2 public:  3int h1;   4void hf();   5;  （圖8）接著建立一個結構體I，多重繼承G和H，代碼和內存分布見下圖：1 class I : public G, public H   2 public:   

25、3int i1;   4void _if();   5;  （圖9）struct I : G, H int i1; void _if();從上述圖中可以直觀地看到：在G對象中（圖7），內嵌的C基類對象的數據緊跟在G的數據之后。在H對象中（圖8），內嵌的C基類對象的數據也緊跟在H的數據之后，但是，在I對象中（圖9），內存布局就并非如此了。VC+實現的內存布局中，G對象實例中G對象和C對象之間的偏移（圖7），不同于I對象實例中G對象和C對象之間的偏移（圖9）。當我們使用指針訪問虛基類成員變量時，由于指針可以是指向派生類

26、實例的基類指針，所以，編譯器不能根據聲明的指針類型計算偏移量，而必須找到另一種從派生類指針計算虛基類位置的間接方法。在VC+ 中，解決上述問題的間接方法是對每個繼承自虛基類的類實例，增加一個隱藏的“虛基類表指針”（virtual base pointer 或virtual base table pointer）成員變量，簡稱vbptr，從而達到間接計算虛基類位置的目的。該變量指向一個全類共享的偏移量表-虛基類表（virtual base table ），簡稱vbtable，從圖7中可看到表中記錄了兩項內容：該表的第一項是GdGvbptrG（ In G, the displacement of

27、Gs virtual base pointer to G 意思是：在G中，G的虛基類表指針與G對象的指針之間的偏移量 ），在32位平臺上，如圖7的Visual Studio 2010 編譯后G的內存分布圖可知其值為0，說明G的虛基類表指針與G對象的指針之間的偏移量為0；該表的第二項是 GdGvbptrC（ In G, the displacement of Gs virtual base pointer to C 意思是：在G中，G的虛基類表指針與C對象的指針之間的偏移量 ），從圖中可知G的虛基類表指針與對象的指針之間的偏移量為8。同樣，在I實例中的G對象實例也有 “虛基類表指針”，不過該指針

28、指向一個適用于“G處于I之中”的虛基類表，表中一項為IdGvbptrC，值為20（圖9）。 除了VC+，在其它的實現方式中，有一種是在派生類中使用指針成員變量。這些指針成員變量指向派生類的虛基類，每個虛基類一個指針。這種方式的優(yōu)點是：獲取虛基類地址時，所用代碼比較少。然而，編譯器優(yōu)化代碼時通常都可以采取措施避免重復計算虛基類地址。況且，這種實現方式還有一個大弊端：從多個虛基類派生時，類實例將占用更多的內存空間；獲取虛基類的虛基類的地址時，需要多次使用指針，從而效率較低等等。 觀察前面的G、H和I， 我們可以得到如下關于VC+虛繼承下內存布局的結論：1 首先排列非虛繼承的基類實例；2 有虛基類時

29、，為每個基類增加一個隱藏的vbptr，除非已經從非虛繼承的類那里繼承了一個vbptr；3 排列派生類的新數據成員；4 在實例最后，排列每個虛基類的一個實例。 該布局安排使得虛基類的位置隨著派生類的不同而“浮動不定”，但是，非虛基類因此也就湊在一起，彼此的偏移量固定不變。2、成員變量 介紹了類布局之后，我們接著考慮對于不同的繼承方式，訪問成員變量的開銷進行研究。 2.1 沒有繼承 沒有任何繼承關系時，訪問成員變量和C語言的情況完全一樣：從指向對象的指針，考慮一定的偏移量即可。1C * pc;  /pc是指向C的指針2pc->c1; / *(pc

30、60;+ dCc1);  C* pc;pc->c1; / *(pc + dCc1);訪問C的成員變量c1，只需要在pc上加上固定的偏移量dCc1（在類C的實例pc中，實例pc指針地址與其c1成員變量之間的偏移量值），再獲取該指針的內容即可,內存分布見圖3,此時的開銷和C語言一樣比較少。 2.2 單繼承由于派生類實例與其基類實例之間的偏移量是常數0，所以，可以直接利用基類指針和基類成員之間的偏移量關系，如此計算得以簡化。1D * pd; /D從C單繼承，pd為指向D的指針2pd->c1; / *(pd + 

31、;dDC + dCc1); / *(pd + dDc1);   3pd->d1; / *(pd + dDd1);  D* pd;pd->c1; / *(pd + dDC + dCc1); / *(pd + dDc1);pd->d1; / *(pd + dDd1); a. 當訪問基類成員c1時，計算步驟本來應該為“pd+dDC+dCc1”，即為先計算D對象和C對象之間的偏移，再在此基礎上加上C對象指針與成員變量c1 之間的偏移量。

32、然而，由于dDC恒定為0，所以直接計算C對象地址與c1之間的偏移就可以了。 b. 當訪問派生類成員d1時，直接計算偏移量。內存分布見圖4,此時從上述的分析可知，開銷還是和C語言一樣比較少。 2.3 多重繼承雖然派生類與某個基類之間的偏移量可能不為0，然而，該偏移量總是一個常數。只要是個常數，訪問成員變量，計算成員變量偏移時的計算就可以被簡化?？梢娂词箤τ诙嘀乩^承來說，訪問成員變量開銷仍然不大，內存分布見圖6。1F* pf; /  F繼承自C和E，pf是指向F對象的指針2pf->c1; / *(pf + dFC 

33、;+ dCc1); / *(pf + dFc1);   3pf->e1; / *(pf + dFE + dEe1); / *(pf + dFe1);   4pf->f1; / *(pf + dFf1);  F* pf;pf->c1; / *(pf + dFC + dCc1); / *(pf + dFc1);pf->e1; /

34、 *(pf + dFE + dEe1); / *(pf + dFe1);pf->f1; / *(pf + dFf1);a. 訪問C類成員c1時，F對象與內嵌C對象的相對偏移為0，可以直接計算F和c1的偏移； b. 訪問E類成員e1時，F對象與內嵌E對象的相對偏移是一個常數，F和e1之間的偏移計算也可以被簡化； c. 訪問F自己的成員f1時，直接計算偏移量。 2.4 虛繼承 當類有虛基類時，訪問非虛基類的成員仍然是計算固定偏移量的問題。然而，訪問虛基類的成員變量，開銷就增大了 ，因為必須經過如下步驟才能獲得成員變量的地址：1. 獲取“虛基類表指針”；2. 獲取虛基類表中某一表項的內容；3.

35、 把內容中指出的偏移量加到“虛基類表指針”的地址上。 然而，事情并非永遠如此。正如下面訪問I對象的c1成員那樣，如果不是通過指針訪問，而是直接通過對象實例，則派生類的布局可以在編譯期間靜態(tài)獲得，偏移量也可以在編譯時計算，因此也就不必要根據虛基類表的表項來間接計算了。1I * pi; /  pi是指向I對象的指針2pi->c1; / *(pi + dIGvbptr + (*(pi+dIGvbptr)1 + dCc1);   3pi->g1; /&

36、#160;*(pi + dIG + dGg1); / *(pi + dIg1);   4pi->h1; / *(pi + dIH + dHh1); / *(pi + dIh1);   5pi->i1; / *(pi + dIi1);   6I i;   7i.c1; 

37、/ *(&i + IdIC + dCc1); / *(&i + IdIc1);  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; /

38、*(&i + IdIC + dCc1); / *(&i + IdIc1);I繼承自G和H，G和H的虛基類是C，pi是指向I對象的指針,內存分布見圖9。a. 訪問虛基類C的成員c1時，dIGvbptr是“在I中，I對象指針與G的“虛基類表指針”之間的偏移”，*(pi + dIGvbptr)是虛基類表的開始地址，*(pi + dIGvbptr)1是虛基類表的第二項的內容-在I對象中，G對象的“虛基類表指針”與虛基類之間的偏移，dCc1是C對象指針與成員變量c1之間的偏移； b. 訪問非虛基類G的成員g1時，直接計算偏移量； c. 訪問非虛基類H的成員h1時，直接計算偏移量； d.

39、訪問自身成員i1時，直接使用偏移量； e. 當聲明了一個對象實例，用點“.”操作符訪問虛基類成員c1時，由于編譯時就完全知道對象的布局情況，所以可以直接計算偏移量。 當訪問類繼承層次中，多層虛基類的成員變量時，情況又如何呢？比如，訪問虛基類的虛基類的成員變量時？一些實現方式為：保存一個指向直接虛基類的指針，然后就可以從直接虛基類找到它的虛基類，逐級上推。VC+優(yōu)化了這個過程。 VC+在虛基類表中增加了一些額外的項，這些項保存了從派生類到其各層虛基類的偏移量。3、強制轉化 如果沒有虛基類的問題，將一個指針強制轉化為另一個類型的指針代價并不高昂。如果在要求轉化的兩個指針之間有“基類-派生類”關系，

40、編譯器只需要簡單地在兩者之間加上或者減去一個偏移量即可（并且該量還往往為0）。1F * pf;   2(C*)pf; / (C*)(pf ? pf + dFC : 0); / (C*)pf;   3(E*)pf; / (E*)(pf ? pf + dFE : 0);  F* pf;(C*)pf; / (C*)(pf ? pf + dFC : 0);

41、 / (C*)pf;(E*)pf; / (E*)(pf ? pf + dFE : 0);C和E是F的基類，內存分布見圖6，將F的指針pf轉化為C*或E*，只需要將pf加上一個相應的偏移量。轉化為C類型指針C*時，不需要計算，因為F和C之間的偏移量為 0。轉化為E類型指針E*時，必須在指針上加一個非0的偏移常量dFE。C+規(guī)范要求NULL指針在強制轉化后依然為NULL，（代碼的解釋中用了三目運算符 “？：”）因此在做強制轉化需要的運算之前，VC+會檢查指針是否為NULL。當然，這個檢查只有當指針被顯示或者隱式轉化為相關類型指針時才進行；當在派生類對象中調用基類的方法，派生類指針在后臺被轉化為一個

42、基類的Const “this” 指針時，這個檢查就不需要進行了，因為在此時，該指針一定不為NULL。正如你猜想的，當繼承關系中存在虛基類時，強制轉化的開銷會比較大。具體說來，和訪問虛基類成員變量的開銷相當。1I* pi;   2(G*)pi; / (G*)pi;   3(H*)pi; / (H*)(pi ? pi + dIH : 0);   4(C*)pi; / (C*)(pi ? (p

43、i+dIGvbptr + (*(pi+dIGvbptr)1) : 0);  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的虛基類。（內存分布見（圖9）a. 強制轉化pi為G*時，由于G*和I*的地址相同，不需要計算； b. 強制轉化pi為H*時，只需要考慮一個常量偏移； c. 強制轉化pi為C*時，所

44、作的計算和訪問虛基類成員變量的開銷相同，首先得到G的虛基類表指針，再從虛基類表的第二項中取出G到虛基類C的偏移量，最后根據pi、虛基類表偏移和虛基類C與虛基類表指針之間的偏移計算出C*。 一般說來，當從派生類中訪問虛基類成員時，應該先強制轉化派生類指針為虛基類指針，然后一直使用虛基類指針來訪問虛基類成員變量。這樣做，可以避免每次都要計算虛基類地址的開銷。見下例。 1 . pi->c1 . pi->c1 .2 C* pc = pi; . pc->c1 . pc->c1 .前者一直使用派生類指針pi，故每次訪問c1都有計算虛基類地址的較大開銷；后者先將pi轉化為虛基類指針p

45、c，故后續(xù)調用可以省去計算虛基類地址的開銷。4、成員函數 一個C+成員函數只是類范圍內的又一個成員。X類每一個非靜態(tài)的成員函數都會接受一個特殊的隱藏參數this指針，類型為X* const。該指針在后臺初始化為指向成員函數工作于其上的對象。同樣，在成員函數體內，成員變量的訪問是通過在后臺計算與this指針的偏移來進行。1 class P   2 public:   3int p1;   4void pf(); /類P的非虛成員函數  5virtual vo

46、id pvf(); / 類P的虛成員函數   6;  （圖10）struct P int p1; void pf(); / new virtual void pvf(); / new;P有一個非虛成員函數pf()，以及一個虛成員函數pvf()(有關多態(tài)和虛函數的知識見附3. C+之多態(tài)性與虛函數)。很明顯，虛成員函數的處理方法，在VC+ 中，與虛繼承的處理方式如出一轍，這樣同樣也造成對象實例占用了更多內存空間，因為實例需增加一個隱藏的“虛函數表指針”（virtual function pointer 或 virtual fu

47、nction table pointer）成員變量，簡稱vfptr，從而達C+的多態(tài)目的。（注：可以讓成員函數操作一般化，用基類的指針指向不同的派生類的對象時，基類指針調用其虛成員函數，則會調用其真正指向對象的成員函數，而不是基類中定義的成員函數（只要派生類改寫了該成員函數）。若不是虛函數，則不管基類指針指向的哪個派生類對象，調用時都會調用基類中定義的那個函數）該變量指向一個全類共享的偏移量表-虛函數表（virtual function table ），簡稱vftable。這一點以后還會談到。這里要特別指出的是，聲明非虛成員函數不會造成任何對象實例的內存開銷?，F在，考慮P:pf()的定義。1v

48、oid P:pf()  / 實際是：void P:pf(P *const this)   2 +p1;   /實際是： +(this->p1);   3  void P:pf() / void P:pf(P *const this) +p1; / +(this->p1);這里P:pf()接受了一個隱藏的this指針參數，對于每個非靜態(tài)成員函數調用，編譯器都會自動加上這個this參數。同時，注意成員變量訪問

49、也許比看起來要代價高昂一些，因為成員變量訪問通過this指針進行，在有的繼承層次下，this指針需要進行調整，所以訪問的開銷可能會比較大。然而，從另一方面來說，編譯器通常會把this指針緩存到寄存器中，所以，成員變量訪問的代價不會比訪問局部變量的效率更差。（在win32位編譯模式下訪問局部變量時，需要到EBP寄存器中得到棧指針，再加上局部變量與棧頂的偏移（局部變量與EBP寄存器值的偏移），所以訪問成員變量的過程將與訪問局部變量的開銷相似）。4.1 覆蓋成員函數 和成員變量一樣，成員函數也會被繼承。與成員變量不同的是，通過在派生類中重新定義基類函數，一個派生類可以覆蓋，或者說替換掉基類的函數定義

50、。覆蓋是靜態(tài) （根據成員函數的靜態(tài)類型在編譯時決定）還是動態(tài) （通過對象指針在運行時動態(tài)決定），依賴于成員函數是否被聲明為“虛函數”。 Q從P繼承了成員變量和成員函數。Q聲明了pf()，覆蓋了P:pf()。Q還聲明了pvf()，覆蓋了P:pvf()虛函數。Q還聲明了新的非虛成員函數qf()，以及新的虛成員函數qvf()。1 class Q : public P    2 public:  3int q1;   4void pf(); / 覆蓋 P

51、:pf   5void qf(); / 新建   6void pvf(); /覆蓋 P:pvf   7virtual void qvf(); / 新建   8;  struct Q : P int q1; void pf(); / overrides P:pf void qf(); / new void pvf(); / overrides P:pvf virtual void qvf(); /

52、new;（圖11）請看下面對于非虛函數的調用：1P p; P* pp = &p; Q q; P* ppq = &q; Q* pq = &q;   2pp->pf(); / pp->P:pf(); / P:pf(pp);   3ppq->pf(); / ppq->P:pf(); / 

53、P:pf(P*)ppq);   4pq->pf(); / pq->Q:pf(); / Q:pf(pq);  5pq->qf(); / pq->Q:qf(); / Q:qf(pq);  對于非虛的成員函數來說，調用哪個成員函數是在編譯時，根據“->”操作符左邊指針表達式的類型靜態(tài)決定的。特別地，即使ppq指向Q的實例，ppq->pf()仍然調用的是P:pf()，因為ppq被聲明為“P*”。（注意，此時“->”操作符左

54、邊的指針類型決定隱藏的this參數的類型。）請看下面對于虛函數的調用：1pp->pvf(); / pp->P:pvf(); / P:pvf(pp);   2ppq->pvf(); / ppq->Q:pvf(); / Q:pvf(Q*)ppq);   3pq->pvf(); / pq->Q:pvf(); / Q:pvf(pq); 對于虛函數調用來說，調用哪個成員函數在運行時 決定。不管“-&g

55、t;”操作符左邊的指針表達式的類型如何，調用的虛函數都是由指針實際指向的實例類型所決定。比如，盡管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); （錯誤?。榱藢崿F這種機制，引入了隱藏的vfptr 成員變量。 一個vfptr被加入到類中（如果類中沒有的話），該vfptr指向類的虛函數表（vf

56、table）。類中每個虛函數在該類的虛函數表中都占據一項。每項保存一個對于該類適用的虛函數的地址。因此，調用虛函數的過程如下：取得實例的vfptr；通過vfptr得到虛函數表的一項；通過虛函數表該項的函數地址間接調用虛函數。也就是說，在普通函數調用的參數傳遞、調用、返回指令開銷外，虛函數調用還需要額外的開銷。 回頭再看看P和Q的內存布局（見（圖10）（圖11），可以發(fā)現，VC+編譯器把隱藏的vfptr成員變量放在P和Q實例的開始處。這就使虛函數的調用能夠盡量快一些。實際上，VC+的實現方式是，保證任何有虛函數的類的第一項永遠是vfptr。這就可能要求在實例布局時，在基類前插入新的vfptr，或

57、者要求在多重繼承時，雖然在右邊，然而有vfptr的基類放到左邊沒有vfptr的基類的前面（如下）。1class CA   2 public:    int a;   3class CB   4 public:    int b;   5class CL : public CB, public CA  

58、0;6 public:    int c;  class CA int a;class CB int b;class CL : public CB, public CA int c;對于CL類，它的內存布局是：（圖12）但是，改造CA如下：1class CA   2   3 public:  4int a;   5virtual void seta( int _a )

59、  a = _a;    6;  class CA int a; virtual void seta( int _a ) a = _a; ;對于同樣繼承順序的CL，內存布局是：（圖13）許多C+的實現會共享或者重用從基類繼承來的vfptr。比如，Q并不會有一個額外的vfptr，指向一個專門存放新的虛函數qvf()的虛函數表。qvf項只是簡單地追加到P的虛函數表的末尾（見（圖11）。如此一來，單繼承的代價就不算高昂。一旦一個實例有vfptr了，它就不需要更多的vfptr。新的派生類可以引入更多的虛函數，這些

60、新的虛函數只是簡單地在已存在的，“每類一個”的虛函數表的末尾追加新項。 4.2 多重繼承下的虛函數 如果從多個有虛函數的基類繼承，一個實例就有可能包含多個vfptr。考慮如下的R和S類：1 class R    2 public:3int r1;   4virtual void pvf(); /新建   5 virtual void rvf(); / 新建   6;  （圖14）stru

61、ct R int r1; virtual void pvf(); / new virtual void rvf(); / new;  1 class S : public P, public R    2 public:3int s1;   4void pvf(); / 覆蓋 P:pvf 和 R:pvf   5void rvf(); /覆蓋 R:rvf   

62、6void svf(); / 新建   7;  （圖15）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

63、()。1S s; S* ps = &s;   2(P*)ps)->pvf(); / (*(P*)ps)->P:vfptr0)(S*)(P*)ps)   3(R*)ps)->pvf(); / (*(R*)ps)->R:vfptr0)(S*)(R*)ps)   4ps->pvf();       /上面的其中一個調用 S:pvf()&

64、#160; S s; S* ps = &s;(P*)ps)->pvf(); / (*(P*)ps)->P:vfptr0)(S*)(P*)ps)(R*)ps)->pvf(); / (*(R*)ps)->R:vfptr0)(S*)(R*)ps)ps->pvf(); / one of the above; calls S:pvf()調用(P*)ps)->pvf()時，先到P的虛函數表中取出第一項，然后把(P*)ps轉化為S*作為this指針傳遞進去；調用(R*)ps)->pvf()時，先到R的虛函數表中取出第一項，然后把(R*)ps轉化為S

65、*作為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*。調整塊內容就是圖15中的“thunk1: this-= sdPR; goto S:p

66、vf”，先根據P和R在S中的偏移，調整this為P*，也就是S*，然后跳轉到相應的虛函數處執(zhí)行。（具體詳細說明見后面的4.4調整塊）在微軟VC+實現中，對于有虛函數的多重繼承，只有當派生類虛函數覆蓋了多個基類的虛函數時，才使用調整塊。  4.3 地址點與“邏輯this調整” 考慮下一個虛函數S:rvf()，該函數覆蓋了R:rvf()。我們都知道S:rvf()必須有一個隱藏的S*類型的this參數。但是，因為也可以用R*來調用rvf()，也就是說，R的rvf虛函數可能以如下方式被用到：1(R*)ps)->rvf(); / (*(R*)ps)->R:vfp

67、tr1)(R*)ps)  (R*)ps)->rvf(); / (*(R*)ps)->R:vfptr1)(R*)ps)所以，大多數實現用另一個調整塊將傳遞給rvf的R*轉換為S*。還有一些實現在S的虛函數表末尾添加一個特別的虛函數項，該虛函數項提供方法，從而可以直接調用ps->rvf()，而不用先轉換R*。VC+的實現不是這樣，VC+有意將S:rvf編譯為接受一個指向S中嵌套的R實例，而非指向S實例的指針（我們稱這種行為是“給派生類的指針類型與該虛函數第一次被引入時接受的指針類型相同”）。所有這些在后臺透明發(fā)生，對成員變量的存取，成員函數的this指針，都進行“邏輯this調整”。 當然，在debugger中，必須對這種this調整進行補償。1ps->rv