类的内存布局-sizeof（转）_sizeof 类内存分布-优快云博客

本文详细探讨了C++中类的内存布局，包括空类、带有虚函数的类、单继承、多继承以及菱形继承的情况。通过实例展示了如何计算类的大小，分析了虚函数表指针的影响以及字节对齐的规则。同时，提到了非虚拟继承与虚拟继承在内存使用上的差异，尤其是虚函数表的处理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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