zoukankan      html  css  js  c++  java

  • 【C++ Primer | 15】C++类内存分布

    C++类内存分布

    书上类继承相关章节到这里就结束了，这里不妨说下C++内存分布结构，我们来看看编译器是怎么处理类成员内存分布的，特别是在继承、虚函数存在的情况下。

    下面可以定义一个类，像下面这样：

    1 class Base
2 {
3     int a;
4     int b;
5 public:
6     void CommonFunction();
7 };

    然后编译一下，可以看到输出框里面有这样的排布：

    这里不想花精力在内存对齐因素上，所以成员变量都设为int型。

    从这里可以看到普通类的排布方式，成员变量依据声明的顺序进行排列（类内偏移为0开始），成员函数不占内存空间。

    2. 再看下继承，往后面添加如下代码：

     1 class Base
 2 {
 3     int a;
 4     int b;
 5 public:
 6     void CommonFunction();
 7 };
 8 
 9 class DerivedClass: public Base
10 {
11     int c;
12 public:
13     void DerivedCommonFunction();
14 };

    编译，然后看到如下的内存分布(父类的内存分布不变，这里只讨论子类成员变量的内存分布)：

    可以看到子类继承了父类的成员变量，在内存排布上，先是排布了父类的成员变量，接着排布子类的成员变量，同样，成员函数不占字节。

    下面给基类加上虚函数，暂时注释掉DerivedClass，看一下这时的内存排布：

    1 class Base
2 {
3     int a;
4     int b;
5 public:
6     void CommonFunction();
7     void virtual VirtualFunction();
8 };

    这个内存结构图分成了两个部分，上面是内存分布，下面是虚表，我们逐个看。VS所带编译器是把虚表指针放在了内存的开始处（0地址偏移），然后再是成员变量；下面生成了虚表，紧跟在&Base1_meta后面的0表示，这张虚表对应的虚指针在内存中的分布，下面列出了虚函数，左侧的0是这个虚函数的序号，这里只有一个虚函数，所以只有一项，如果有多个虚函数，会有序号为1，为2的虚函数列出来。

    编译器是在构造函数出创建一个对象时创建这个虚表指针以及虚表的。

    那么编译器是如何利用虚表指针与虚表来实现多态的呢？是这样的，当创建一个含有虚函数的父类的对象时，编译器在对象构造时将虚表指针指向父类的虚函数；同样，当创建子类的对象时，编译器在构造函数里将虚表指针（子类只有一个虚表指针，它来自父类）指向子类的虚表（这个虚表里面的虚函数入口地址是子类的）。

    所以，如果是调用Base *p = new Derived();生成的是子类的对象，在构造时，子类对象的虚指针指向的是子类的虚表，接着由Derived*到Base*的转换并没有改变虚表指针，所以这时候p->VirtualFunction，实际上是p->vfptr->VirtualFunction，它在构造的时候就已经指向了子类的VirtualFunction，所以调用的是子类的虚函数，这就是多态了。

    3. 下面加上子类，并在子类中添加虚函数，像下面这样：

     1 class Base
 2 {
 3     int a;
 4     int b;
 5 public:
 6     void CommonFunction();
 7     void virtual VirtualFunction();
 8 };
 9 
10 class DerivedClass: public Base
11 {
12     int c;
13 public:
14     void DerivedCommonFunction();
15     void virtual VirtualFunction();
16 };

    可以看到子类内存的排布如下：

    上半部是内存分布，可以看到，虚表指针被继承了，且仍位于内存排布的起始处，下面是父类的成员变量a和b，最后是子类的成员变量c，注意虚表指针只有一个，子类并没有再生成虚表指针了；下半部的虚表情况与父类是一样的。

    4. 我们把子类换个代码，像这样：

     1 class Base
 2 {
 3     int a;
 4     int b;
 5 public:
 6     void CommonFunction();
 7     void virtual VirtualFunction();
 8 };
 9 
10 class DerivedClass1 : public Base
11 {
12     int c;
13 public:
14     void DerivedCommonFunction();
15     void virtual VirtualFunction2();
16 };

    注意到这时我们并没有覆写父类的虚方法，而是重声明了一个新的子类虚方法，内存分布如下：

     还是只有一个虚表指针，但是下方虚表的内容变化了，虚表的0号是父类的VirtualFunction，而1号放的是子类的VirtualFunction2。也就是说，如果定义了DerivedClass的对象，那么在构造时，虚表指针就会指向这个虚表，以后如果调用的是VirtualFunction，那么会从父类中寻找对应的虚函数，如果调用的是VirtualFunction2，那么会从子类中寻找对应的虚函数。

    5. 我们再改造一下子类，像这样：

     1 class Base
 2 {
 3     int a;
 4     int b;
 5 public:
 6     void CommonFunction();
 7     void virtual VirtualFunction();
 8 };
 9 
10 class DerivedClass1 : public Base
11 {
12     int c;
13 public:
14     void DerivedCommonFunction();
15     void virtual VirtualFunction();
16     void virtual VirtualFunction2();
17 };

     我们既覆写父类的虚函数，也有新添的虚函数，那么可以料想的到，是下面的这种内存分布：

     

    多继承子类的内存布局

    多继承子类的内存布局

    下面讨论多继承派生类，代码如下：

     1 class A
 2 {
 3 public:
 4     int dataA;
 5 };
 6  
 7 class B : public A
 8 {
 9 public:
10     int dataB;
11 };
12  
13 class C : public A
14 {
15 public:
16     int dataC;
17 };
18  
19 class D : public B, public C
20 {
21 public:
22     int dataD;
23 };

    内存布局如下：

    为了跟后文加以比较，我们再来看看B和C的内存布局：

        

    下面来讨论多重继承，代码如下：

     1 class Base
 2 {
 3     int a;
 4     int b;
 5 public:
 6     void CommonFunction();
 7     void virtual VirtualFunction();
 8 };
 9 
10 
11 class DerivedClass1: public Base
12 {
13     int c;
14 public:
15     void DerivedCommonFunction();
16     void virtual VirtualFunction();
17 };
18 
19 class DerivedClass2 : public Base
20 {
21     int d;
22 public:
23     void DerivedCommonFunction();
24     void virtual VirtualFunction();
25 };
26 
27 class DerivedDerivedClass : public DerivedClass1, public DerivedClass2
28 {
29     int e;
30 public:
31     void DerivedDerivedCommonFunction();
32     void virtual VirtualFunction();
33 };

     内存分布从父类到子类，依次如下：

    Base中有一个虚表指针，地址偏移为0

    DerivedClass1继承了Base，内存排布是先父类后子类。

    下面我们重点看看这个类DerivedDerivedClass，由外向内看，它并列地排布着继承而来的两个父类DerivedClass1与DerivedClass2，还有自身的成员变量e。DerivedClass1包含了它的成员变量c，以及Base，Base有一个0地址偏移的虚表指针，然后是成员变量a和b；DerivedClass2的内存排布类似于DerivedClass1，注意到DerivedClass2里面竟然也有一份Base。

    里有两份虚表了，分别针对DerivedClass1与DerivedClass2，在&DerivedDericedClass_meta下方的数字是首地址偏移量，靠下面的虚表的那个-16表示指向这个虚表的虚指针的内存偏移，这正是DerivedClass2中的{vfptr}在DerivedDerivedClass的内存偏移。

    虚继承内存布局

     1 class A
 2 {
 3 public:
 4     int dataA;
 5 };
 6  
 7 class B : virtual public A
 8 {
 9 public:
10     int dataB;
11 };
12  
13 class C : virtual public A
14 {
15 public:
16     int dataC;
17 };
18  
19 class D : public B, public C
20 {
21 public:
22     int dataD;
23 };
    我们看看B、C、D类的内存布局情况：

     

     1 class A
 2 {
 3 public:
 4     int dataA;
 5 };
 6  
 7 class B : virtual public A
 8 {
 9 public:
10     int dataB;
11 };
12  
13 class C : virtual public A
14 {
15 public:
16     int dataC;
17 };
18  
19 class D : public B, public C
20 {
21 public:
22     int dataD;
23 };

    B、C的内存布局：
       

    D的内存布局：

    我们可以看到，菱形继承体系中的子类在内存布局上和普通多继承体系中的子类类有很大的不一样。对于类B和C，sizeof的值变成了12，除了包含类A的成员变量dataA外还多了一个指针vbptr，类D除了继承B、C各自的成员变量dataB、dataA和自己的成员变量外，还有两个分别属于B、C的指针。

    那么类D对象的内存布局就变成如下的样子：

    • vbptr：继承自父类B中的指针
    • int dataB：继承自父类B的成员变量
    • vbptr：继承自父类C的指针
    • int dataC：继承自父类C的成员变量
    • int dataD：D自己的成员变量
    • int A：继承自父类A的成员变量

    显然，虚继承之所以能够实现在多重派生子类中只保存一份共有基类的拷贝，关键在于vbptr指针。那vbptr到底指的是什么？又是如何实现虚继承的呢？其实上面的类D内存布局图中已经给出答案：

     

    实际上，vbptr指的是虚基类表指针（virtual base table pointer），该指针指向了一个虚表（virtual table），虚表中，第一项记录了vbptr与本类的偏移地址；第二项是vbptr到共有基类元素之间的偏移量。在这个例子中，类B中的vbptr指向了虚表D::$vbtable@B@，虚表表明公共基类A的成员变量dataA距离类B开始处的位移为20，这样就找到了成员变量dataA，而虚继承也不用像普通多继承那样维持着公共基类的两份同样的拷贝，节省了存储空间。

     

    参考资料
  • 相关阅读:
    Qt QString to char*
    数组和指针的异同
    QTableWidget的使用和美工总结
    static——第一次执行与它以后执行时结果不一样
    电子签名技术之疑惑
    三十六 多进程
    三十五 序列化
    vs 单元测试
    三十四 操作文件和目录
    三十三 StringIO和BytesIO
  • 原文地址：https://www.cnblogs.com/sunbines/p/9455132.html
Copyright © 2011-2022 走看看