1 sizeof一个空类
class A { };
cout<<sizeof(A)<<endl;//1
注：class A是一个空类型，它的实例不包含任何信息，本来求sizeof应该是0。
但当我们声明该类型的实例的时候，它必须在内存中占有一定的空间，否则无法使用这些实例。
至于占用多少内存，由编译器决定。Visual Studio 2008中每个空类型的实例占用一个byte的空间。
2 sizeof一个带有构造和析构函数的类
class B
{
public:
B() {}
~B() {}
};
cout<<szieof(B)<<endl;//1
注：class B在class A的基础上添加了构造函数和析构函数。
由于构造函数和析构函数的调用与类型的实例无关（调用它们只需要知道函数地址即可），在它的实例中不需要增加任何信息。
所以sizeof(B)和sizeof(A)一样，在Visual Studio 2008中都是1。
3 sizeof一个带有虚函数的类
class C
{
public:
C() {}
virtual ~C() {}
};
cout<<sizeof(C)<<endl;//4
注：class C在class B的基础上把析构函数标注为虚拟函数。C++的编译器一旦发现一个类型中有虚拟函数，
就会为该类型生成虚函数表，并在该类型的每一个实例中添加一个指向虚函数表的指针。
在32位的机器上，一个指针占4个字节的空间，因此sizeof(C)是4。
C++标准规定类的大小不为0，空类的大小为1，当类不包含虚函数和非静态数据成员时，其对象大小也为1。
如果在类中声明了虚函数（不管是1个还是多个），那么在实例化对象时，编译器会自动在对象里安插一个指针指向虚函数表VTable，
在32位机器上，一个对象会增加4个字节来存储此指针，它是实现面向对象中多态的关键。而虚函数本身和其他成员函数一样，是不占用对象的空间的。
4 sizeof一个带有成员变量的类
class D {
char ch;
void func() { }
};
class E {
char ch1; //占用1字节
char ch2; //占用1字节
virtual void func() { }
};
class F {
int in;
virtual void func() { }
};
cout << "D的大小"<< sizeof(D) << endl;//1
cout << "E的大小" << sizeof(E) << endl;//8
cout << "F的大小" << sizeof(E) << endl;//8
注：类和结构体一样，需要考虑数据对齐和补齐规则
5 sizeof简单继承类
class COneMember
{
public:
COneMember(int iValue = 0){m_iOne = iValue;};
private:
int m_iOne;
};
内存结构：00 00 00 00 //m_iOne
class CTwoMember:public COneMember
{
private:
int m_iTwo;
};
内存结构：
00 00 00 00 //m_iOne
CC CC CC CC //m_iTwo
注：子类成员接在父类成员之后
class CThreemember:public CTwoMember
{
public:
CThreemember(int iValue=10) {m_iThree = iValue;};
private:
int m_iThree;
};
内存结构：
00 00 00 00 //m_iOne
CC CC CC CC //m_iTwo
0A 00 00 00 //m_iThree
注：孙类成员接在子类之后，再再继承就依此类推了。
cout<<sizeof（COneMember）<<endl;//4
cout<<sizeof（CTwoMember）<<endl;//8
cout<<sizeof（CThreeeMember）<<endl;//12
6 sizeof多重继承类
class ClassA
{
public:
ClassA(int iValue=1){m_iA = iValue;};
private:
int m_iA;
};
class ClassB
{
public:
ClassB(int iValue=2){m_iB = iValue;};
private:
int m_iB;
};
class ClassC
{
public:
ClassC(int iValue=3){m_iC = iValue;};
private:
int m_iC;
};
class CComplex :public ClassA, public ClassB, public ClassC
{
public:
CComplex(int iValue=4){m_iComplex = iValue;};
private:
int m_iComplex;
};
内存结构：
01 00 00 00 //A
02 00 00 00 //B
03 00 00 00 //C
04 00 00 00 //Complex
注：也是父类成员先出现在前边，我想这都足够好理解。
cout<<sizeof(CComplex )<<endl;//16
7 sizeof 虚继承的类
class CTwoMember:virtual public COneMember
{
private:
int m_iTwo;
};
内存结构：
E8 2F 42 00 //指针，指向一个关于偏移量的数组，且称之虚基类偏移量表指针
CC CC CC CC // m_iTwo
00 00 00 00 // m_iOne（虚基类数据成员）
长度：12
注：virtual让长度增加了4，其实是多了一个指针。
8 sizeof一个闭合虚继承类
内存结构：
14 30 42 00 //ClassB的虚基类偏移量表指针
02 00 00 00 //m_iB
C4 2F 42 00 //ClassC的虚基类偏移量表指针
03 00 00 00 //m_iC
04 00 00 00 //m_iComplex
01 00 00 00 //m_iA
长度：24
注：虚基类的成员m_iA只出现了一次，而且是在最后边。虚继承利用一个“虚基类偏移量表指针”来使得虚基类即使被重复继承也只会出现一次。
9 sizeof一个带有static数据成员的类
class CStaticNull
{
public:
CStaticNull(){printf("Construct/n");}
~CStaticNull(){printf("Desctruct/n");}
static void Foo(){printf("Foo/n");}
static int m_iValue;
};
内存结构：和空类相同
长度：1
注：static成员不会占用类的大小，static成员的存在区域为静态区，可认为它们是“全局”的，只是不提供全局的访问而已，这跟C的static其实没什么区别。
10 带有一个虚函数的空类
class CVirtualNull
{
public:
CVirtualNull(){printf("Construct/n");}
~CVirtualNull(){printf("Desctruct/n");}
virtual void Foo(){printf("Foo/n");}
};
内存结构：
00 31 42 00 //指向虚函数表的指针（虚函数表后面简称“虚表”）
00423100:（虚表）
41 10 40 00 //指向虚函数Foo的指针
00401041:
E9 78 02 00 00 E9 C3 03 … //函数Foo的内容（看不懂）
长度：4
注：虚函数的类长度就增加了4，这个4其实就是个指针，指向虚函数表的指针，上面这个例子中虚表只有一个函数指针，值就是“0x00401041”，指向的这个地址就是函数的入口了
11 sizeof一个继承带虚函数的类
class CVirtualDerived : public CVirtualNull
{
public:
CVirtualDerived(){m_iVD=0xFF;};
~CVirtualDerived(){};
private:
int m_iVD;
};
长度：8
内存结构：
3C 50 42 00 //虚表指针
FF 00 00 00 //m_iVD
0042503C:（虚表）
23 10 40 00 //指向虚函数Foo的指针，如果这时候创建一个CVirtualNull对象，会发现它的 虚表的内容跟这个一样
注：由于父类带了虚函数，子类就算没有显式声明虚函数，虚表还是存在的，虚表存放的位置跟父类不同，但内容是同的，也就是对父类虚表的复制。
12 sizeof子类带虚函数，基类带虚函数
class CVirtualDerived: public CVirtualNull
{
public:
CVirtualDerived(){m_iVD=0xFF;};
~CVirtualDerived(){};
virtual void Foo2(){printf("Foo2/n");};
private:
int m_iVD;
};
内存结构：
24 61 42 00 //虚表指针
FF 00 00 00 //m_iVD
00426124:（虚表）
23 10 40 00
50 10 40 00
长度：8
注：虚表还是只有一张，不会因为增加了新的虚函数而多出另一张来，新的虚函数的指针将添加在复制了的虚表的后面。