类的大小

c++中类所占的大小计算并没有想象中那么简单，因为涉及到虚函数成员，静态成员，虚继承，多继承以及空类等，不同情况有对应的计算方式，在此对各种情况进行总结。

首先要明确一个概念，平时所声明的类只是一种类型定义，它本身是没有大小可言的。 我们这里指的类的大小，其实指的是类的对象所占的大小。因此，如果用sizeof运算符对一个类型名操作，得到的是具有该类型实体的大小。
关于类/对象大小的计算

    首先，类大小的计算遵循结构体的对齐原则
    类的大小与普通数据成员有关，与成员函数和静态成员无关。即普通成员函数，静态成员函数，静态数据成员，静态常量数据成员均对类的大小无影响
    虚函数对类的大小有影响，是因为虚函数表指针带来的影响
    虚继承对类的大小有影响，是因为虚基表指针带来的影响
    空类的大小是一个特殊情况,空类的大小为1

解释说明

    静态数据成员之所以不计算在类的对象大小内，是因为类的静态数据成员被该类所有的对象所共享，并不属于具体哪个对象，静态数据成员定义在内存的全局区。
    空类的大小，以及含有虚函数，虚继承，多继承是特殊情况，接下来会一一举例说明

注意：因为计算涉及到内置类型的大小，接下来的例子运行结果是在64位gcc编译器下得到的。int的大小为4，指针大小为8

一.简单情况的计算

#include<iostream>
using namespace std;

class base
{
    public:
    base()=default;
    ~base()=default;
    private:
    static int a;
    int b;
    char c;

};

int main()
{
    base obj;
    cout<<sizeof(obj)<<endl;
}

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22

计算结果：8
静态变量a不计算在对象的大小内，由于字节对齐，结果为4+4=8

二.空类的大小

本文中所说是C++的空类是指这个类不带任何数据，即类中没有非静态(non-static)数据成员变量，没有虚函数(virtual function)，也没有虚基类(virtual base class)。

直观地看，空类对象不使用任何空间，因为没有任何隶属对象的数据需要存储。然而，C++标准规定，凡是一个独立的(非附属)对象都必须具有非零大小。换句话说，c++空类的大小不为0
为了验证这个结论，可以先来看测试程序的输出。

#include <iostream>
using namespace std;

class NoMembers
{
};

int main()
{
    NoMembers n;  // Object of type NoMembers.
    cout << "The size of an object of empty class is: "
         << sizeof(n) << endl;
}

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13

输出:

The size of an object of empty class is: 1

    1

C++标准指出，不允许一个对象（当然包括类对象）的大小为0，不同的对象不能具有相同的地址。这是由于：

new需要分配不同的内存地址，不能分配内存大小为0的空间
避免除以 sizeof(T)时得到除以0错误
故使用一个字节来区分空类。
但是，有两种情况值得我们注意

第一种情况，涉及到空类的继承。
当派生类继承空类后，派生类如果有自己的数据成员，而空基类的一个字节并不会加到派生类中去。例如

class Empty {};
struct D : public Empty { int a;};

    1
    2

sizeof(D)为4。

第二中情况，一个类包含一个空类对象数据成员。

class Empty {};
class HoldsAnInt {
    int x;
    Empty e;
};

    1
    2
    3
    4
    5

sizeof(HoldsAnInt)为8。
因为在这种情况下，空类的1字节是会被计算进去的。而又由于字节对齐的原则，所以结果为4+4=8。

继承空类的派生类，如果派生类也为空类，大小也都为1。

三.含有虚函数成员

首先，要介绍一下虚函数的工作原理：

　　虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）来实现的。编译器必需要保证虚函数表的指针存在于对象实例中最前面的位置（这是为了保证正确取到虚函数的偏移量）。
　　每当创建一个包含有虚函数的类或从包含有虚函数的类派生一个类时，编译器就会为这个类创建一个虚函数表（VTABLE）保存该类所有虚函数的地址，其实这个VTABLE的作用就是保存自己类中所有虚函数的地址，可以把VTABLE形象地看成一个函数指针数组，这个数组的每个元素存放的就是虚函数的地址。在每个带有虚函数的类 中，编译器秘密地置入一指针，称为v p o i n t e r（缩写为V P T R），指向这个对象的V TA B L E。 当构造该派生类对象时，其成员VPTR被初始化指向该派生类的VTABLE。所以可以认为VTABLE是该类的所有对象共有的，在定义该类时被初始化；而VPTR则是每个类对象都有独立一份的，且在该类对象被构造时被初始化。

假设我们有这样的一个类：

class Base {

public:

virtual void f() { cout << "Base::f" << endl; }

virtual void g() { cout << "Base::g" << endl; }

virtual void h() { cout << "Base::h" << endl; }

};

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11

当我们定义一个这个类的实例，Base b时，其b中成员的存放如下：
这里写图片描述
指向虚函数表的指针在对象b的最前面。

虚函数表的最后多加了一个结点，这是虚函数表的结束结点，就像字符串的结束符”\0”一样，其标志了虚函数表的结束。这个结束标志的值在不同的编译器下是不同的。在vs下，这个值是NULL。而在linux下，这个值是如果1，表示还有下一个虚函数表，如果值是0，表示是最后一个虚函数表。
因为对象b中多了一个指向虚函数表的指针，而指针的sizeof是8，因此含有虚函数的类或实例最后的sizeof是实际的数据成员的sizeof加8。

例如：

class Base {

public:

int a;

virtual void f() { cout << "Base::f" << endl; }

virtual void g() { cout << "Base::g" << endl; }

virtual void h() { cout << "Base::h" << endl; }
};

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12

sizeof(Base)为16。
vptr指针的大小为8，又因为对象中还包含一个int变量，字节对齐得8+8=16。

下面将讨论针对基类含有虚函数的继承讨论:

（1）在派生类中不对基类的虚函数进行覆盖，同时派生类中还拥有自己的虚函数，比如有如下的派生类：

class Derived: public Base
{

public:

virtual void f1() { cout << "Derived::f1" << endl; }

virtual void g1() { cout << "Derived::g1" << endl; }

virtual void h1() { cout << "Derived::h1" << endl; }

};

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12

基类和派生类的关系如下：
这里写图片描述

当定义一个Derived的对象d后，其成员的存放如下：
这里写图片描述
可以发现：

1）虚函数按照其声明顺序放于表中。

2）基类的虚函数在派生类的虚函数前面。

此时基类和派生类的sizeof都是数据成员的大小+指针的大小8。

（2）在派生类中对基类的虚函数进行覆盖，假设有如下的派生类：

class Derived: public Base
{

public:

virtual void f() { cout << "Derived::f" << endl; }

virtual void g1() { cout << "Derived::g1" << endl; }

virtual void h1() { cout << "Derived::h1" << endl; }

};

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12

基类和派生类之间的关系：其中基类的虚函数f在派生类中被覆盖了
这里写图片描述

当我们定义一个派生类对象d后，其d的成员存放为：
这里写图片描述
可以发现：

1）覆盖的f()函数被放到了虚表中原来基类虚函数的位置。

2）没有被覆盖的函数依旧。

派生类的大小仍是基类和派生类的非静态数据成员的大小+一个vptr指针的大小

这样，我们就可以看到对于下面这样的程序，

Base *b = new Derive();

b->f();

由b所指的内存中的虚函数表的f()的位置已经被Derive::f()函数地址所取代，于是在实际调用发生时，是Derive::f()被调用了。这就实现了多态。

（3）多继承：无虚函数覆盖
假设基类和派生类之间有如下关系：
这里写图片描述
对于派生类实例中的虚函数表，是下面这个样子：
这里写图片描述

我们可以看到：

1） 每个基类都有自己的虚表。

2） 派生类的成员函数被放到了第一个基类的表中。（所谓的第一个基类是按照声明顺序来判断的）

由于每个基类都需要一个指针来指向其虚函数表，因此d的sizeof等于d的数据成员加上三个指针的大小。

（4）多重继承，含虚函数覆盖
假设，基类和派生类又如下关系：派生类中覆盖了基类的虚函数f
这里写图片描述
下面是对于派生类实例中的虚函数表的图：
这里写图片描述
我们可以看见，三个基类虚函数表中的f()的位置被替换成了派生类的函数指针。这样，我们就可以任一静态类型的基类类来指向派生类，并调用派生类的f()了。如：

Derive d;

Base1 *b1 = &d;

Base2 *b2 = &d;

Base3 *b3 = &d;

b1->f(); //Derive::f()

b2->f(); //Derive::f()

b3->f(); //Derive::f()

b1->g(); //Base1::g()

b2->g(); //Base2::g()

b3->g(); //Base3::g()

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19

此情况派生类的大小也是类的所有非静态数据成员的大小+三个指针的大小

举一个例子具体分析一下大小吧：

#include<iostream>
using namespace std;

class A     
{     
};    

class B     
{  
    char ch;     
    virtual void func0()  {  }   
};   

class C    
{  
    char ch1;  
    char ch2;  
    virtual void func()  {  }    
    virtual void func1()  {  }   
};  

class D: public A, public C  
{     
    int d;     
    virtual void func()  {  }   
    virtual void func1()  {  }  
};     
class E: public B, public C  
{     
    int e;     
    virtual void func0()  {  }   
    virtual void func1()  {  }  
};  

int main(void)  
{  
    cout<<"A="<<sizeof(A)<<endl;    //result=1  
    cout<<"B="<<sizeof(B)<<endl;    //result=16      
    cout<<"C="<<sizeof(C)<<endl;    //result=16  
    cout<<"D="<<sizeof(D)<<endl;    //result=16  
    cout<<"E="<<sizeof(E)<<endl;    //result=32  
    return 0;  
}  

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44

结果分析:
1.A为空类，所以大小为1
2.B的大小为char数据成员大小+vptr指针大小。由于字节对齐,大小为8+8=16
3.C的大小为两个char数据成员大小+vptr指针大小。由于字节对齐，大小为8+8=16
4.D为多继承派生类，由于D有数据成员，所以继承空类A时，空类A的大小1字节并没有计入当中，D继承C，此情况D只需要一个vptr指针，所以大小为数据成员加一个指针大小。由于字节对齐,大小为8+8=16
5.E为多继承派生类，此情况为我们上面所讲的多重继承，含虚函数覆盖的情况。此时大小计算为数据成员的大小+2个基类虚函数表指针大小
考虑字节对齐，结果为8+8+2*8=32

四.虚继承的情况

对虚继承层次的对象的内存布局，在不同编译器实现有所区别。
在这里，我们只说一下在gcc编译器下，虚继承大小的计算。

它在gcc下实现比较简单，不管是否虚继承，GCC都是将虚表指针在整个继承关系中共享的，不共享的是指向虚基类的指针。

class A {

    int a;

};

class B:virtual public A{

    virtual void myfunB(){}

};

class C:virtual public A{

    virtual void myfunC(){}

};

class D:public B,public C{

    virtual void myfunD(){}

};

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23

以上代码中sizeof(A)=16,sizeof(B)=24,sizeof(C)=24,sizeof(D)=32.
解释：A的大小为int大小加上虚表指针大小。B，C中由于是虚继承因此大小为int大小加指向虚基类的指针的大小。B,C虽然加入了自己的虚函数，但是虚表指针是和基类共享的，因此不会有自己的虚表指针，他们两个共用虚基类A的虚表指针。D由于B,C都是虚继承，因此D只包含一个A的副本，于是D大小就等于int变量的大小+B中的指向虚基类的指针+C中的指向虚基类的指针+一个虚表指针的大小,由于字节对齐，结果为8+8+8+8=32。
————————————————
版权声明：本文为CSDN博主「rotation ㅤ   」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/fengxinlinux/article/details/72836199