C++类的大小

        C++类的大小，是一个比较经典的问题，学过C++后，应该对类大小有清晰的认识，长话短说，本文精简凝练，我们进入正题！！！

1.类的大小与什么有关系？

     与类大小有关的因素：普通成员变量，虚函数，继承（单一继承，多重继承，重复继承，虚拟继承）

     与类大小无关的因素：静态成员变量，静态成员函数及普通成员函数

2.空类

     空类即什么都没有的类，按上面的说法，照理说大小应该是0，但是，空类的大小为1，因为空类可以实例化，实例化必然在内存中占有一个位置，因此，编译器为其优化为一个字节大小。

      某类继承自空类：

  1. class base
  2. {
  3. };
  4. class derived:public base
  5. {
  6.  private:
  7.     int a;
  8. }

    此时，derived类的大小为4，derived类的大小是自身int成员变量的大小，至于为什么没有加上父类base的大小1是因为空白基优化的问题，在空基类被继承后，子类会优化掉基类的1字节的大小，节省了空间大小，提高了运行效率。

3.一般类的大小（注意内存对齐）

首先上两个类的示例：

  1. class base1
  2. {
  3. private:
  4.     char a;
  5.     int b;
  6.     double c;
  7. };
  8. class base2
  9. {
  10. private:
  11.     char a;
  12.     double b;
  13.     int c;
  14. };

虽然上述两个类成员变量都是一个char，一个int，一个double，但是不同的声明顺序，会导致不同的内存构造模型，对于base1，base2，其成员排列是酱紫的：

base1：


base2：


base 1类对象的大小为16字节，而base 2类对象的大小为24字节，因为不同的声明顺序，居然造成了8字节的空间差距，因此，我们将来在自己声明类时，一定要注意到内存对齐问题，优化类的对象空间分布。

4.含虚函数的单一继承

首先呈上示意类：（64位，指针大小8字节）

  1. class Base
  2. {
  3. private:
  4.     char a;
  5. public:
  6.     virtual void f();
  7.     virtual void g();
  8. };
  9. class Derived:public Base
  10. {
  11. private:
  12.     int b;
  13. public:
  14.     void f();
  15. };
  16. class Derived1:public Base
  17. {
  18. private:
  19.     double b;
  20. public:
  21.     void g();
  22.     virtual void h();
  23. };

基类Base中含有一个char型成员变量，以及两个虚函数，此时Base类的内存布局如下：


内存布局的最一开始是vfptr（virtual function ptr）即虚函数表指针（只要含虚函数，一定有虚函数表指针，而且该指针一定位于类内存模型最前端），接下来是Base类的成员变量，按照在类里的声明顺序排列，当然啦，还是要像上面一样注意内存对齐原则！


继承类Derived继承了基类，重写了Base中的虚函数f()，还添加了自己的成员变量，即int型的b，这时，Derived的类内存模型如下：

 

此种情况下，最一开始的还是虚函数表指针，只不过，在Derived类中被重写的虚函数f()在对应的虚函数表项的Base::f()已经被替换为Derived::f()，接下来是基类的成员变量char a，紧接着是继承类的成员变量int b，按照其基类变量声明顺序与继承类变量声明顺序进行排列，并注意内存对齐问题。


继承类Derived1继承了基类，重写了Base中的虚函数g()，还添加了自己的成员变量（即double型的b）与自己的虚函数（virtual h() ），这时，Derived1的类内存模型如下：


此种情况下，Derived1类一开始仍然是虚函数表指针，只是在Derived1类中被重写的虚函数g()在对应的虚函数表项的Base::g()已经被替换为Derived1::g()，新添加的虚函数virtual h()位于虚函数表项的后面，紧跟着基类中最后声明的虚函数表项后，接下来仍然是基类的成员变量，紧接着是继承类的成员变量。

5 含虚函数的多重继承

首先上示意类：

  1. class Base1
  2. {
  3. private:
  4.     char a;
  5. public:
  6.     virtual void f();
  7.     virtual void g1();
  8. };
  9. class Base2
  10. {
  11. private:
  12.     int b;
  13. public:
  14.     virtual void f();
  15.     virtual void g2();
  16. };
  17. class Base3
  18. {
  19. private:
  20.     double c;
  21. public:
  22.     virtual void f();
  23.     virtual void g3();
  24. };
  25. class Derived:public Base1, public Base2, public Base3
  26. {
  27. private:
  28.     double d;
  29. public:
  30.     void f();
  31.     virtual void derived_func();
  32. }

首先继承类多重继承了三个基类，此外继承类重写了三个基类中都有的虚函数virtual f()，还添加了自己特有的虚函数derived_func()，那么，新的继承类内存布局究竟是什么样子的呢？请看下图！先来看3个基类的内存布局：


紧接着是继承类Derived的内存布局：


首先，Derived类自己的虚函数表指针与其声明继承顺序的第一个基类Base1的虚函数表指针合并，此外，若Derived类重写了基类中同名的虚函数，则在三个虚函数表的对应项都应该予以修改，Derived中新添加的虚函数位于第一个虚函数表项后面，Derived中新添加的成员变量位于类的最后面，按其声明顺序与内存对齐原则进行排列。

6. 菱形继承的问题及解决方案：虚拟继承

首先在讲这一节之前，先贴出几个重要的信息（干货）：

（1）不同环境下虚拟继承对类大小的影响

在vs环境下，采用虚拟继承的继承类会有自己的虚函数表指针（假如基类有虚函数，并且继承类添加了自己新的虚函数）

在gcc环境下及mac下使用clion，采用虚拟继承的继承类没有自己的虚函数表指针（假如基类有虚函数，无论添加自己新的虚函数与否），而是共用父类的虚函数表指针

关于以上这一点请详见我的博客：https://blog.csdn.net/longjialin93528/article/details/79874558  ，这里对此进行了超级详细的讲解。

（2）虚拟继承会给继承类添加一个虚基类指针（virtual base ptr 简称vbptr），其位于类虚函数指针后面，成员变量前面，若基类没有虚函数，则vbptr其位于继承类的最前端

关于虚拟继承，首先我们看看为什么需要虚拟继承及虚极继承解决的问题。

虚极继承主要是为了解决菱形继承下公共基类的多份拷贝问题：

  1. class Base
  2. {
  3. public:
  4.     int a;
  5. }
  6. class Base1:virtual public Base
  7. {
  8. }
  9. class Base2:virtual public Base
  10. {
  11. }
  12. class Derived:public Base1,public Base2
  13. {
  14. private:
  15.     double b;
  16. public:
  17. }


Base1与Base2本身没有任何自身添加的数据成员与虚函数，因此，Base1与Base2都只含有从Base继承来的int a与一个普通的方法，然后Derived又从Base1与Base2继承，这时会导致二义性问题及重复继承下空间浪费的问题：

二义性问题：

  1. Derived de;
  2. de.a=10;//这里是错误的，因为不知道操作的是哪个a

重复继承下空间浪费：

Derived重复继承了两次Base中的int a，造成了无端的空间浪费


虚拟继承是怎么解决上述问题的？

虚基继承可以使得上述菱形继承情况下最终的Derived类只含有一个Base类，Base类在虚拟继承后，位于继承类内存布局最后面的位置，继承类通过vbptr寻找基类中的成员及vfptr。

虚拟继承对继承类的内存布局影响可以先看以下示例代码，理解以后，我们在最后列出上述菱形虚拟继承情况下Base1，Base2与Derived代码及内存布局，看到虚拟继承起的作用。

  1. class base
  2. {
  3. public:
  4.     int a
  5.     virtual void f();
  6. }
  7. class derived:virtual public base
  8. {
  9. public:
  10.     double d;
  11.     void f();
  12. }

Derived类内存布局如下图，由于虚拟继承，Derived只会有一个最初基类的拷贝，该拷贝位于类对象模型的最下面，而想要访问到基类的元素，需要vbptr指明基类的位置（vbptr作用），假如Base中含有虚函数，而继承类中没有增添自己的新的虚函数，那么Derived类统一的布局如下：


如果添加了自己的新的虚函数(代码如下)：

  1. class base
  2. {
  3. public:
  4.     int a
  5.     virtual void f();
  6. }
  7. class derived:virtual public base
  8. {
  9. public:
  10.     double d;
  11.     void f();
  12.     virtual void g();//这是Derived类自己新添加的虚函数
  13. }

那么Derived在VC下继承类会有自己的虚函数指针，而在Gcc下是共用基类的虚函数指针，其分布如下


    

现在有了上述代码的理解我们可以写出菱形虚拟继承代码及每个类的内存布局：

  1. class Base
  2. {
  3. public:
  4.     int a;}
  5. class Base1:public virtual Base
  6. {
  7. }
  8. class Base2:public virtual Base
  9. {
  10. }
  11. class Derived:public Base1,public Base2
  12. {
  13. private:
  14.     double b;
  15. public:
  16. }


带实线的框是类确确实实有的，带虚线是针对Base，及Base1，Base2做了扩展后的情况：

Base有虚函数，Base1还添加了自己新的虚函数，Base1也有自己成员变量，Base2添加了自己新的虚函数，Base2也有自己成员变量，则上图全部虚线中的部分都将存在于对象内存布局中。


码字画图不易，点个赞再走呗～～～也是给我继续创作的动力！
posted @ 2019-05-04 16:06  unique_ptr  阅读(384)  评论(0)  编辑  收藏  举报