類的大小（sizeof(類)）

    首先，sizeof（）計算的是一個對象在記憶體中占有多少位元組而不是多少位。

    我們自己定義一個類，聲明一個類的對象之後進行編譯運作，會有一個類的執行個體化過程，即在記憶體為該類的對象配置設定一塊記憶體位址區域。

#include<iostream>
#include<stdlib.h>
using namespace std;

class a {};
class b{};
class c:public a
{
    virtual void fun()=0;
};
class d:public b,public c{};
int main()
{
    cout<<"sizeof(a)"<<sizeof(a)<<endl;
    cout<<"sizeof(b)"<<sizeof(b)<<endl;
    cout<<"sizeof(c)"<<sizeof(c)<<endl;
    cout<<"sizeof(d)"<<sizeof(d)<<endl;
    return 0;

}
           

程式執行的輸出結果為：

sizeof(a) =1

sizeof(b)=1

sizeof(c)=4

sizeof(d)=8 

無論是空類還是其他的類，都可以執行個體化，在記憶體中為其配置設定唯一的記憶體位址空間。對于空類，要使其執行個體化後記憶體空間是獨一無二的，編譯器會自動為其添加一個位元組的記憶體，該記憶體空間并不儲存任何變量。

而類c是由類a派生而來，它裡面有一個純虛函數，由于有虛函數的原因，有一個指向虛函數的指針（vptr），在３２位的系統配置設定給指針的大小為４個位元組，是以最後得到c類的大小為４．

類d的大小更讓初學者疑惑吧，類d是由類b，c派生迩來的，它的大小應該為二者之和５，為什麼卻是８　　呢？這是因為為了提高執行個體在記憶體中的存取效率．類的大小往往被調整到系統的整數倍．并采取就近的法則，裡哪個最近的倍數，就是該類的大小，是以類d的大小為８個位元組．

當然在不同的編譯器上得到的結果可能不同，但是這個實驗告訴我們初學者，不管類是否為空類，均可被執行個體化（空類也可被執行個體化），每個被執行個體都有一個獨一無二的位址．

#include<iostream>
#include<stdlib.h>
using namespace std;
class a
{
pivate: 
int data;
};

class b
{ 
private:
     int data;
static int data1;
};
int b::data1=0;
void mian()
{
    cout<<"sizeof(a)="<<sizeof(a)<<endl;
    cout<<"sizeof(b)="<<sizeof(b)<<endl;
}
           

執行結果為：

sizeof(a)=4;

sizeof(b)=4;

為什麼類b多了一個資料成員，卻大小和類a的大小相同呢？因為：類b的靜态資料成員被編譯器放在程式的一個global data members中，它是類的一個資料成員．但是它不影響類的大小，不管這個類實際産生　了多少執行個體，還是派生了多少新的類，靜态成員資料在類中永遠隻有一個實體存在，而類的非靜态資料成員隻有被執行個體化的時候，他們才存在．但是類的靜态資料成員一旦被聲明，無論類是否被執行個體化，它都已存在．可以這麼說，類的靜态資料成員是一種特殊的全局變量．

#include<iostream>
#incude<stdlib.h>
using namespace std;
class A{
public :
A(int a)
           

{
   x=a;
           

}
 void f(int x)
           

{
   cout<<x<<endl;
           

}
 ~A(){}

private:
   int x;
   int g;
   };
class B{
public:
private:
    int data; int data2;
    static int xs;
};
int B::xs=0;
void main()
           

{
    A s(10);
    s.f(10);
    cout<<"sozeof(a)"<<sizeof(A)<<endl;
    cout<<"sizeof(b)"<<sizeof(B)<<endl;
}
           

10 ,

sizeof(a) 8

sizeof(b) 8

它們的結果均相同，可以看出類的大小與它當中的構造函數，析構函數，以及其他的成員函數無關，隻與它當中的成員資料有關．

從以上的幾個例子不難發現類的大小：

１．為類的非靜态成員資料的類型大小之和．

２．有編譯器額外加入的成員變量的大小，用來支援語言的某些特性（如：指向虛函數的指針）．

３．為了優化存取效率，進行的邊緣調整．

４.與類中的構造函數，析構函數以及其他的成員函數無關．

#include <iostream>
#include <stdlib.h>
using namespace std;
class A
{
	virtual void Funa(){};
};

class B : public virtual  A
{
	char j[3];
public:
	virtual void Funb(){};
	virtual void fun(void);
	virtual void fun1(void){};
	virtual void fun2(void);
};
class C : public virtual B
{
	char i[3];
public:
	virtual void Func(){};
};

int main()
{
	cout<<sizeof(A)<<endl;
	cout<<sizeof(B)<<endl;
	cout<<sizeof(C)<<endl;
	return 0;
}
           

1、對于class A，由于隻有一個虛函數，那麼必須得有一個對應的虛函數表，來記錄對應的函數入口位址。同時在class A的記憶體空間中之需要有個vfptr_A指向該表。sizeof（A）也很容易确定，為4。

2、對于class B，由于class B虛基礎了class A，同時還擁有自己的虛函數。那麼class B中首先擁有一個vfptr_B，指向自己的虛函數表。還有char j[3]，做一次alignment，一般大小為4。可虛繼承該如何實作咧？首先要通過加入一個虛l類指針（記vbptr_B_A）來指向其父類，然後還要包含父類的所有内容。有些複雜了，不過還不難想象。sizeof（B）= 4＋4＋4＋4＝16（vfptr_B、char j[3]做alignment、vbptr_B_A和class A）。

3、在接着是class C了。class C首先也得有個vfptr_C，然後是char i[3]，然後是vbptr_C_B，然後是class B，是以sizeof（C）＝4＋4＋4＋16＝28（vfptr_C、char i[3]做alignment、vbptr_C_A和class B）。

結果為4、16、28。

結論:

1、VC在編譯時會把vfptr放到類的頭部；

2、VC采用虛表指針（vbtbl_ptr）來确定某個類所繼承的虛類。

3、VC會重新調整虛繼承的父類在子類中記憶體布局。（具體規則還不清楚）

4、VC中虛類表中的第一項是無意義的，可能是為了保證sizeof（虛類表）!=0;後面的内容為父類在子類中相對該虛類表指針的偏移量。