一個類，有成員變量：靜態與非靜態之分；而成員函數有三種：靜態的、非靜態的、虛的。
那麼這些個東西在內存中到底是如何分配的呢？
以一個例子來說明：
#include"iostream.h"
class CObject
{
public:
static int a;
CObject();
~CObject();
void Fun();
private:
int m_count;
int m_index;
};
void CObject::Fun()
{
cout<<"Fun\n"<<endl;
}
CObject::CObject()
{
cout<<"Construct!\n";
}
CObject::~CObject()
{
cout<<"Destruct!\n";
}
int CObject::a=1;
void main()
{
cout<<"Sizeof(CObject):"<<sizeof(CObject)<<endl;
cout<<"CObject::a="<<CObject::a<<endl;
CObject myObject;
cout<<"sizeof(myObject):"<<sizeof(myObject)<<endl;
cout<<"sizeof(int)"<<sizeof(int)<<endl;
}這是我的一段測試代碼，
運行結果是：
Sizeof(CObject):8
CObject::a=1
Construct!
sizeof(myObject):8
sizeof(int)4
Destruct!
我有疑問如下：
（1）C++中，應該是對象纔會被分配內存空間吧？？爲什麼CObject內存大小是8，剛好和兩個成員變量的大小之和一致！難道還沒實例化的時候，類就已經有了內存空間了？
（2）當對象生成了之後，算出的內存大小怎麼還是8，函數難道不佔用內存空間嗎？至少應該放個函數指針在裏面的吧？內存是怎樣佈局的？
（3）靜態成員應該是屬於類的，怎麼類的大小中沒有包含靜態成員的大小？
下面分別解答如下：
1）Sizeof(CObject)是在編譯時就計算了的，一個類定義了，它所佔的內存編譯器就已經知道了，這時只是得到它佔用的大小，並沒有分配內存操作。也可以這樣想：編譯器肯定知道大小了，這與分配內存空間無關，知道大小了，以後實例化了才能知道要分配多大。
2）類的普通成員、靜態成員函數是不佔類內存的，至於你說的函數指針在你的類中有虛函數的時候存在一個虛函數表指針，也就是說如果你的類裏有虛函數則sizeof(CObject)的值會增加4個字節。
其實類的成員函數實際上與普通的全局函數一樣。
只不過編譯器在編譯的時候，會在成員函數上加一個參數，傳入這個對象的指針。
成員函數地址是全局已知的，對象的內存空間里根本無須保存成員函數地址。
對成員函數(非虛函數)的調用在編譯時就確定了。
像 myObject.Fun() 這樣的調用會被編譯成形如 _CObject_Fun( &myObject )
的樣子。
函數是不算到sizeof中的，因爲函數是代碼，被各個對象共用，跟數據處理方式不同。對象中不必有函數指針，因爲對象沒必要知道它的各個函數的地址（調用函數的是其他代碼而不是該對象）。
類的屬性是指類的數據成員，他們是實例化一個對象時就爲數據成員分配內存了，而且每個對象的數據成員是對立的，而成員函數是共有的~
靜態成員函數與一般成員函數的唯一區別就是沒有this指針，因此不能訪問非靜態數據成員。總之，程序中的所有函數都是位於代碼區的。
3）靜態成員並不屬於某個對象，sizeof取的是對象大小。
知道了上面的時候，就可以改一下來看看：
我也補充一些：
class
CObject
{
public:
static int
a;
CObject();
~CObject();
void
Fun();
private:
double
m_count; //這裏改成了double
int m_index;
};
這個類用sizeof()測出來的大小是
2*sizeof(double)=16
class
CObject
{
public:
static int
a;
CObject();
~CObject();
void
Fun();
private:
char
m_count; //這裏改成了char
int m_index;
};
大小是2*sizeof(int)=8
class
CObject
{
public:
static int
a;
CObject();
~CObject();
void
Fun();
private:
double
m_count; //這裏改成了double
int m_index;
char c;
};
sizeof(char)+sizeof(int)
<sizeof(double) 所以大小是2*sizeof(double)
其實這裏還有一個是內存對齊的問題。
空類大小是1。
另外要注意的一些問題：
先看一個空的類佔多少空間？
class Base
{
public:
Base();
~Base();
};
class Base { public: Base(); ~Base(); };
注意到我這裏顯示聲明瞭構造跟析構，但是sizeof(Base)的結果是1.
因爲一個空類也要實例化，所謂類的實例化就是在內存中分配一塊地址，每個實例在內存中都有獨一無二的地址。同樣空類也會被實例化，所以編譯器會給空類隱含的添加一個字節，這樣空類實例化之後就有了獨一無二的地址了。所以空類的sizeof爲1。
而析構函數，跟構造函數這些成員函數，是跟sizeof無關的，也不難理解因爲我們的sizeof是針對實例，而普通成員函數，是針對類體的，一個類的成員函數，多個實例也共用相同的函數指針，所以自然不能歸爲實例的大小，這在我的另一篇博文有提到。
接着看下面一段代碼
class Base
{
public:
Base();
virtual ~Base(); //每個實例都有虛函數表
void set_num(int num) // 普通成員函數，爲各實例公有，不歸入sizeof統計
{
a=num;
}
private:
int a; //佔4字節
char *p; //4字節指針
};
class Derive:public Base
{
public:
Derive():Base(){};
~Derive(){};
private:
static int st; //非實例獨佔
int d; //佔4字節
char *p; //4字節指針
};
int main()
{
cout<<sizeof(Base)<<endl;
cout<<sizeof(Derive)<<endl;
return 0;
}class Base {
public:
Base();
virtual ~Base(); //每個實例都有虛函數表
void set_num(int num){ a=num; } //普通成員函數，爲各實例公有，不歸入sizeof統計
private:
int a; //佔4字節
char *p; //4字節指針
};
class Derive:public Base
{
public:
Derive():Base(){};
~Derive(){};
private:
static int st; //非實例獨佔
int d; //佔4字節
char *p; //4字節指針
};
int main()
{
cout<<sizeof(Base)<<endl;
cout<<sizeof(Derive)<<endl;
return 0;
}
結果自然是
12
20
Base類裏的int a;char *p;佔8個字節。
而虛析構函數virtual ~Base();的指針佔4子字節。
其他成員函數不歸入sizeof統計。
Derive類首先要具有Base類的部分，也就是佔12字節。
int d;char *p;佔8字節
static int st;不歸入sizeof統計
所以一共是20字節。
在考慮在Derive里加一個成員char c;
class Derive:public Base
{
public:
Derive():Base(){};
~Derive(){};
private:
static int st;
int d;
char *p;
char c;
};
class Derive:public Base
{
public:
Derive():Base(){};
~Derive(){};
private:
static int st;
int d;
char *p;
char c;
};
這個時候，結果就變成了
12
24
一個char c;增加了4字節，說明類的大小也遵守類似class字節對齊，補齊規則。
具體的可以看網上那篇《5分鐘搞定字節對齊》
至此，我們可以歸納以下幾個原則：
1.類的大小爲類的非靜態成員數據的類型大小之和，也就是說靜態成員數據不作考慮。
2.普通成員函數與sizeof無關。