MSVC++ 對象內存模型深入解析與具體應用

前言：本文之所以強調MSVC, 旨在提醒讀者在不同平臺和解釋器下內存布局和實現上存在差異，但編程思想通用，文中內容大多來自筆者實際工作經驗和網上搜集，力求正確，但水平有限，如有不當之處，敬請指出

面向對象：本文面向有一定C/C++基礎，并且可以讀懂部分匯編的讀者

版權：歡迎轉載，但請注明出處http://m.shnenglu.com/dawnbreak/， 保留對本文的一切權力

目錄
1. C++基本類型與結構體內存布局
                Key words: class,  struct, memory alignment

2．虛表, 多態與動態綁定

                Key words: Virtual Table, polymiorphism

3．對象池

                Key words: object pool , reload, new ,delete

4．內存泄漏檢測

                Key words: memory leak detect

5．智能指針

                Key words: smart pointer

6.   編譯期類型約束
   
                Key words: compile-time ,type-constraint


 Appendix 1: C++堆棧祥解

第二章  虛表, 多態與動態綁定

Key words: Virtual Table, polymiorphism

1．虛表-Virtual Table 多態-polymiorphism

       虛函數表由虛函數的地址組成，表中函數地址的順序和它們第一次出現的順序（即在類定義的順序）一致。若有重載的函數，則替換掉基類函數的地址，事實上你可以簡單的將虛表定義理解如下：

        Int* virtualTable[size]//普通的指針數組而已

         多數情形下，MSVC的類按如下格局分布：

?           指向虛函數表的指針（_vtable_或_vftable_），不過它只在類包括虛函數，以及不能從基類復用合適的函數表時才會被添加。

?           基類。

?             函數成員。

請看如下例子：

#include "stdafx.h"
#include "assert.h"
#include "iostream"
using namespace std;
class A
{
public:
  int b1;
  static int b3;
  int b2;
public:

  virtual void A_virt1()
  {
      std::cout<<"  call of first A's vf"<<std::endl;
  }

  virtual void A_virt2()
  {
      std::cout<<"  call of second A's vf"<<std::endl;
  }

};
int A::b3=100;
//#pragma pack(1)
class B:public A
{
    int a1;
    char b1;
    float c1;
  virtual void A_virt2()
  {
      std::cout<<"  call of second B's vf"<<std::endl;
  }    
  virtual void B_virt1()
  {
        std::cout<<"  call of second B's vf1"<<std::endl;
  }
    virtual void B_virt2()
  {
        std::cout<<"  call of second B's vf2"<<std::endl;
  }
    void getsome();
};
void B::getsome()
{
    int a=1;
}

class D:public A
{
};

class C:public B,public D
{
  virtual void B_virt1()
  {
        std::cout<<"  call of first C's vf"<<std::endl;
  }
};
int _tmain(int argc, _TCHAR* argv[])
{
    typedef void(*pfunc)();
    cout<<"test the class memory layout-virtual table"<<endl;
    C cc;
    (pfunc(((int**)(&cc))[0][0]))();
    (pfunc(((int**)(&cc))[0][1]))();
    (pfunc(((int**)(&cc))[0][2]))();
    (pfunc(((int**)(&cc))[0][3]))();

    system("pause");
    return 0;
}

為了調用虛函數，編譯器首先需要從_vftable_取得函數地址，然后就像調用簡單方法一樣（例如，傳入_this_指針作為隱含參數）。例如：

          cc.A_virt2()

          ;esi = ptr [cc]

          mov eax, [esi]  ;fetch virtual table pointer

          mov ecx, esi

          call [eax+4]  ;call second virtual method

          ;cc->B_virt1()

          ;edi = pC

          lea edi, [esi+8] ;adjust this pointer

          mov eax, [edi]   ;fetch virtual table pointer

          mov ecx, edi

call [eax]       ;call first virtual method


注意到上面class A的內存布局圖，首先是VT指針，然后是成員變量b1,b2， 而對于靜態成員b3并沒有體現，事實上b是存儲在程序的全局靜態數據區，供該類的所有實例共享，這里請注意在classA中虛表中虛函數出現的順序和位置，這一點很重要，接著再看classB中虛函數出現的順序和位置，注意到A_virt1，A_virt2在classA和classB中出現的順序和位置一致，而所不同的是在classB的虛表中A_virt2已經被替換，這就是多態的關鍵所在，每一個虛函數本身其實不過是一個固定的偏移量，而真正實現多態的其實是在編譯器的虛函數表的替換動作.

而對于多繼承情況要復雜一些，例如在ClassC中每一個繼承路徑中都存在一個虛表，如果在沒函數里再加入如下調用：
 (pfunc(((int**)(&cc))[6][0]))();
 (pfunc(((int**)(&cc))[6][1]))();
會輸出：
call of first A's vf
call of second A' vf
這樣一個類中同時存在兩個一抹一樣的函數，那么當你用
C cc;
cc.A_virt2（）時會怎么樣呢？
你會得到以下錯誤：
error C2385: ambiguous access of 'A_virt2'

解決辦法有兩種：
1. 調用時加入域操作符，例如：
cc.A::A_virt2（）;
cc.B::A_virt2( );
這種辦法最穩妥也最清晰
2. 使用虛基類
代碼改動如下：

。。。。。。。
class B:virtual public A
。。。。。。。
class D:virtual public A
。。。。。。。
int _tmain(int argc, _TCHAR* argv[])
{
。。。。。。。
 (pfunc(((int**)(&cc))[0][0]))();
 (pfunc(((int**)(&cc))[0][1]))();
 //(pfunc(((int**)(&cc))[0][2]))();
 //(pfunc(((int**)(&cc))[0][3]))();
 //(pfunc(((int**)(&cc))[6][0]))();
 //(pfunc(((int**)(&cc))[6][1]))();
 cc.A::A_virt2();
 cc.A_virt2();
。。。。。。。。
}

內存布局變為：

多了一個vbtable存儲偏移量，第一個元素存儲vbtable與該類的偏移量，第二個元素存儲vbtable與公共基類的偏移量，而且注意到，vftable@A 的第二個虛函數被定向到B:A_virt2
這樣問題解決了，但是你會得到一個警告：
Warning 1 warning C4250: 'C' : inherits 'B::B::A_virt2' via dominance
顯示繼承了 'B::B::A_virt2‘ ，也就是說你在調用
cc.A_virt2時，默認直接去調用B::A_virt2，這可能并不是你所期望的，所以使用時需要慎重

 1class AA
 2{
 3public:
 4   void test()
 5   {
 6      cout<<"I am class AA!"<<endl;
 7   }
 8};
 9class BB
10{
11public:
12   void test()
13   {
14      cout<<"I am class BB!"<<endl;
15   }
16};
17int _tmain(int argc, _TCHAR* argv[])
18{
19    AA *A=(AA *)(new BB);
20    A->test();
21}

讀者可以想一下以上例子的結果，如果說是I am class BB!

C++沒有你想得那么職能，C++調用函數不過是指針偏移，而一般成員函數代碼是在數據存儲區的共享代碼段，聲明了AA類的指針 A 就已經指定了偏移的起點是類型AA的代碼段起點，這一步就是所謂的動態邦定，而調用->test()；只能得到I am class AA!

也許你要說我并沒有實例化AA怎么會有那一段代碼呢，請注意代碼生成和實例化是完全不同的兩個階段，編譯在編譯時發現你調用了AA::test(); 那么就會載入相應的symbol，程序啟動時就會載入相應代碼段。

也許你還要說沒有用繼承的關系，那么你可以自己試驗一下使BB繼承自AA， 結果還是一樣的

想要實現想要的結果唯一的方法就是使用虛函數來實現動態邦定；