Cpp对象的内存布局(下篇)

Posted on | In

前言

这篇博客是接上一篇,实际上本来是一篇的,但是我为了方便大家阅读,拆成了两篇,毕竟一篇特别长的博客实际上读起来非常的累,分成两篇就好多了.

菱形继承

让我们继续下一个例子,这个例子要复杂一点,是菱形继承,而且涉及到了虚基类.先说一下为什么要虚基类,是为了避免下图这种情况:
image.png

上面图中这种情况,B1和B2的基类都是B(B1和B2对B都是public继承),所以在D对象中我们实际上有两个B的对象,B1对象中有一个,B2对象中有一个,造成空间资源浪费的情况,虽然有些情况下这可能正是我们想要的,有两个B的副本互不影响,但是部分情况,这可能并不是我们想要的.为此,C++引入了虚基类的概念.

虚拟继承的目的就是为了解决重复继承中多个重复间接父类的问题.为了解决上面的问题,我们只需要在B1和B2继承B的语句中在public后面加上关键字virtual即可,这便是虚拟继承,继承图如下所示:
image.png

不过在这里大家要注意下,这个图只是方便大家理解的,我的代码并不是这个结构了,前面的两个例子的概念图和代码中类的结构都是配套的,但是这个例子的两个概念图都是方便大家理解意思的,代码中类的结构并不和这个结构一样,因为这个图表示的类结构比较复杂,我觉得完全没有必要,只要理解虚基类在内存中到底是怎么布局,再复杂的问题都可以分解为我说的三个例子的组合.这几个概念图都是我从上面的那篇博客中截下来的,方便大家理解(主要原因是我懒得自己画这个图了(笑)),其他的结果图和结构都是我自己的,作为代码的参考

下面贴出代码:

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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
#include <iostream>
using namespace std;
struct A {
  A(long v = 10) : x(v) {}
  virtual void foo() { cout << "A::foo" << endl; }
  virtual void orFunc() { cout << "A::orFunc" << endl; }
  long x;
};
struct B : public virtual A {
  B(long v = 20) : y(v) {}
  virtual void orFunc() { cout << "B::orFunc" << endl; }
  virtual void fooB() { cout << "B::foo" << endl; }
  long y;
};
struct C : public virtual A {
  C(long v = 30) : z(v) {}
  virtual void orFunc() { cout << "C::orFunc" << endl; }
  virtual void fooC() { cout << "C::foo" << endl; }
  long z;
};
struct D : public B, public C {
  D(long v = 100) : B(20), C(30), A(10), l(v) {}
  virtual void orFunc() { cout << "D::orFunc" << endl; }
  virtual void fooD() { cout << "D::foo" << endl; }
  long l;
};
typedef void (*func)(void);
void printFunc(long **p, const int &index, const int &num) {
  cout << "p[" << index << "] -> ";
  cout << endl;
  for (int i = 0; i < num; i++) {
    auto pFunc = (func)p[index][i];
    cout << '\t' << "[" << i << "]";
    pFunc();
  }
}
int main() {
  cout << "-----------------------------" << endl;
  A a;
  long **pVtab = (long **)&a;
  cout << "A:" << endl;
  for (int i = 0; i < 2; i++) {
    if ((long)pVtab[i] < 10000)
      cout << dec << (long)pVtab[i] << endl;
    else
      printFunc(pVtab, i, 2);
  }
  cout << "-----------------------------" << endl;
  cout << "B" << endl;
  B b;
  pVtab = (long **)&b;
  for (int i = 0; i < (sizeof(B) / sizeof(long)); i++) {
    if ((long)pVtab[i] < 10000)
      cout << dec << (long)pVtab[i] << endl;
    else {
      if (i == 0)
        printFunc(pVtab, i, 2);
      else
        printFunc(pVtab, i, 1);
    }
  }
  cout << "-----------------------------" << endl;
  cout << "D" << endl;
  D d;
  pVtab = (long **)&d;
  for (int i = 0; i < (sizeof(D) / sizeof(long)); i++) {
    if ((long)pVtab[i] < 10000)
      cout << dec << (long)pVtab[i] << endl;
    else {
      if (0 == i)
        printFunc(pVtab, i, 3);
      else if (2 == i)
        printFunc(pVtab, i, 2);
      else
        printFunc(pVtab, i, 1);
    }
  }
  cout << "-----------------------------" << endl;
}

再贴出结果:
image.png

这里我的结果是三个对象的内存布局,分别是A,B,D,在图上也能看出来,这里需要注意的是当A作为虚基类的时候,A的虚表的第二项并不是直接指向派生类的orFunc(),而是指向一个virtual thunk to实际的函数,这里讲的可能不清楚,不过没关系,等下在图上我会画出来.

下面我画出D对象的内存布局,B对象的内存布局我就不画了,基本差不多.
image.png

下面有几点是我们需要注意的:

  • D仍然和第一个父类(在这里即B)共享虚函数表,虚函数表中函数顺序是先B后D,先声明的靠前,后声明的在后面
  • 重写的函数会覆盖掉基类中的函数,譬如上图中的D::orFunc()覆盖掉了B::orFunc()和C::orFunc().
  • 在这里,A作为虚基类比较孤独(笑),他一个人坐落在对象的底部,和其他对象也没啥联系.
  • 这里的***是有点意思的,我用gdb查看的话,gdb会告诉提示出来:virtual thunk to D::orFunc(),上网查了一下,简单来说像是转化为D::orFunc()的一个函数一样.

结语:到这里,总结的差不多了,费了我一天的时间来查资料,敲代码测试和写博客,不过感觉还是非常充实的,毕竟确实学到了很多很多的东西,毕竟古人说的好”朝闻道夕死可矣”(笑).