sizeof 类

虚继承的话，在子类末尾要多一份指向基类的指针；只保留一份，多的要减去

如果子类重新定义了虚函数，那么它不放在基类的虚表里面，而是单独重新开一份虚表，这个和非虚继承是不同的

----------------------------------------------------

1.class K

{

 

};

sizeof(K) = 1;//空类大小为1

 

2. class A

{

  int a;

  void a();

};

sizeof(A) = 4;//不计算成员函数的空间

 

3. class B

{

   int b;

   virtual void b();

 }

 sizeof(B) = 4+4;//有虚函数，添加虚表指针大小

 

4. class C:virtual public B

{

   int c;

   virtual void c();

};

sizeof(C)=4+4+4+4+4;//虚继承，添加指向基类的指针；虚继承中重新定义了虚函数，则新添加一个虚表指针

 

5. class D:virtual public B

{

   int d;

   virtual void d();

}

sizeof(D)=4+4+4+4+4;

 

6. class E:public C,public D

{

  int e;

}

sizeof(E) = 4+2*(4+4+4+4+4)-4;//只保留一份指向原始基类的指针所以要减4

 

总结：sizeof 类 = 成员变量+虚函数指针。sizeof 继承类 = 本身成员变量+父类的大小，如果是虚拟继成的话，则另外加一个指向父类指针的大小；当多重继承的时候，如例6中，所示，这时候只需要，保留一份指向虚基类B的指针，所以得减掉一个指针的大小。

------------------------------------

类的内存布局-sizeof(类对象)

一、简单对象
#include<iostream.h>
class A
{
public:

int a;

char b;

static int c;

virtual ~A(){};

};

int A::c=123;

int main()
{

A asimple;

cout<<sizeof(asimple)<<endl;

return 0;

} //result=4+4+1+3=12即字节对齐(虚指针+非静态数据成员)

二、单继承

#include<iostream.h>
class A
{
public:

int a;

char b;

static int c;

virtual ~A(){};

};

int A::c=123;

class B:public A
{
public:

int d;

virtual void foob(){};

};

int main()
{

// A asimple;

B bsimple;

cout<<sizeof(bsimple)<<endl;

return 0;

} //result=(4+4+1+3)+4=16即字节对齐(基类size+B自己的非静态数据成员)

三、多继承

#include<iostream.h>
class A
{
public:

int a;

char b;

static int c;

virtual ~A(){};

};

int A::c=123;

class B
{
public:

int d;

virtual void foob(){};

};
class C:public A,public B
{
public:

int e;

};

int main()
{

A asimple;

B bsimple;

C csimple;

cout<<sizeof(asimple)<<endl; //12

cout<<sizeof(bsimple)<<endl; //8

cout<<sizeof(csimple)<<endl;

//12+8+4=24 即字节对齐(基类A大小+基类B大小+C自己的非静态数据成员)

return 0;

}

四、菱形继承
1.非虚拟继承方式
#include<iostream.h>
class A
{
public:

int a;

char b;

static int c;

virtual ~A(){};

virtual void fooa(){};

};

int A::c=123;

class B:public A
{
public:

int d;

virtual void foob(){};

};
class C:public A
{
public:

int e;

};

class D:public B,public C
{
public:

char f;

};

int main()
{

A asimple;

B bsimple;

C csimple;

D dsimple;

cout<<sizeof(asimple)<<endl;//12

cout<<sizeof(bsimple)<<endl;//16

cout<<sizeof(csimple)<<endl;//16

cout<<sizeof(dsimple)<<endl;//16+16+4=36 同多继承方式

return 0;

} 
2.虚拟继承
(1)B中重写fooa(),但不定义新的虚函数
#include<iostream.h>
class A
{
public:

int a;

char b;

static int c;

virtual ~A(){};

virtual void fooa(){};

};

int A::c=123;

class B:virtual public A
{
public:

int d;

// virtual void foob(){};

virtual void fooa(){cout<<"fooa in B"<<endl;};

};
class C:virtual public A
{
public:

int e;

};

class D:public B,public C
{
public:

char f;

};

int main()
{

A asimple;

B bsimple;

C csimple;

D dsimple;

cout<<sizeof(asimple)<<endl;//12

cout<<sizeof(bsimple)<<endl;//20

cout<<sizeof(csimple)<<endl;//20

cout<<sizeof(dsimple)<<endl;//32

return 0;

}

(2)B定义新的虚函数
#include<iostream.h>
class A
{
public:

int a;

char b;

static int c;

virtual ~A(){};

virtual void fooa(){};

};

int A::c=123;

class B:virtual public A
{
public:

int d;

virtual void foob(){cout<<"foob in B"<<endl;};

// virtual void fooa(){cout<<"fooa in B"<<endl;};

};
class C:virtual public A
{
public:

int e;

};

class D:public B,public C
{
public:

char f;

};

int main()
{

A asimple;

B bsimple;

C csimple;

D dsimple;

cout<<sizeof(asimple)<<endl;//12

cout<<sizeof(bsimple)<<endl;//24

cout<<sizeof(csimple)<<endl;//20

cout<<sizeof(dsimple)<<endl;//36

return 0;

}

综合1，2，可见
1.非虚拟继承时，无论派生类是否定义新的虚函数，基类和派生类总是共享一个虚函数表，不需要另加指向虚函数的指针。
2.虚拟继承时，若是派生类只是继承或重写基类中虚函数，则基类和派生类是共享一个虚函数表；若派生类新定义了虚函数，则需要新加一个虚指针指向新的虚函数表。