类的内存布局-sizeof（转）

 

空类：1
没有虚函数：sizeof(数据成员)的和
有虚函数：sizeof(数据成员)的和+sizeof(V表指针);

类的大小不包含静态数据成员大小，静态数据存放

在静态存储区。

一、简单对象
#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.虚拟继承时，若是派生类只是继承或重写基类中虚函数，则基类和派生类是共享一个虚函数表；若派生类新定义了虚函数，则需要新加一个虚指针指向新的虚函数表。