class A { };cout<<sizeof(A)<<endl;//1

class B{public:B() {}~B() {}};cout<<szieof(B)<<endl;//1

class C{public:C() {}virtual ~C() {}};cout<<sizeof(C)<<endl;//4

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

class COneMember{public:COneMember(int iValue = 0){m_iOne = iValue;};private:int m_iOne;};内存结构：00 00 00 00 //m_iOneclass CTwoMember:public COneMember{private:int m_iTwo;};内存结构：00 00 00 00 //m_iOneCC 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_iOneCC CC CC CC //m_iTwo0A 00 00 00 //m_iThree注：孙类成员接在子类之后，再再继承就依此类推了。cout<<sizeof（COneMember）<<endl;//4
cout<<sizeof（CTwoMember）<<endl;//8
cout<<sizeof（CThreeeMember）<<endl;//12

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  //A02 00 00 00  //B03 00 00 00  //C04 00 00 00  //Complex注：也是父类成员先出现在前边，我想这都足够好理解。cout<<sizeof(CComplex )<<endl;//16

class CTwoMember:virtual public COneMember{private:int m_iTwo;};内存结构：E8 2F 42 00 //指针，指向一个关于偏移量的数组，且称之虚基类偏移量表指针CC CC CC CC // m_iTwo00 00 00 00 // m_iOne（虚基类数据成员）长度：12

注：virtual让长度增加了4，其实是多了一个指针。

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其实没什么区别。

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”，指向的这个地址就是函数的入口了

class CVirtualDerived : public CVirtualNull{public:CVirtualDerived(){m_iVD=0xFF;};~CVirtualDerived(){};private:int m_iVD;};长度：8
内存结构：
3C 50 42 00 //虚表指针
FF 00 00 00 //m_iVD0042503C:（虚表）
23 10 40 00 //指向虚函数Foo的指针，如果这时候创建一个CVirtualNull对象，会发现它的        虚表的内容跟这个一样注：由于父类带了虚函数，子类就算没有显式声明虚函数，虚表还是存在的，虚表存放的位置跟父类不同，但内容是同的，也就是对父类虚表的复制。

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_iVD00426124:（虚表）
23 10 40 00
50 10 40 00长度：8
注：虚表还是只有一张，不会因为增加了新的虚函数而多出另一张来，新的虚函数的指针将添加在复制了的虚表的后面。