多重继承的虚方法表

我正在读这篇文章“虚拟方法表"

上面文章中的例子：

class B1 {
public:
  void f0() {}
  virtual void f1() {}
  int int_in_b1;
};

class B2 {
public:
  virtual void f2() {}
  int int_in_b2;
};

class D : public B1, public B2 {
public:
  void d() {}
  void f2() {}  // override B2::f2()
  int int_in_d;
};

B2 *b2 = new B2();
D  *d  = new D();

在文章中，作者介绍了对象的内存布局d是这样的：

          d:
D* d-->      +0: pointer to virtual method table of D (for B1)
             +4: value of int_in_b1
B2* b2-->    +8: pointer to virtual method table of D (for B2)
             +12: value of int_in_b2
             +16: value of int_in_d

Total size: 20 Bytes.

virtual method table of D (for B1):
  +0: B1::f1()  // B1::f1() is not overridden

virtual method table of D (for B2):
  +0: D::f2()   // B2::f2() is overridden by D::f2()

问题是关于d->f2()。致电给d->f2()通过一个B2指针作为this指针所以我们必须做类似的事情：

(*(*(d[+8]/*pointer to virtual method table of D (for B2)*/)[0]))(d+8) /* Call d->f2() */

为什么我们要通过一个B2指针作为this指针不是原来的D指针？？？我们实际上调用的是 D::f2()。根据我的理解，我们应该通过D指针为this到 D::f2() 函数。

___更新____

如果通过一个B2指针为this到 D::f2()，如果我们想访问 D::f2() 的成员怎么办B1D::f2() 中的类？我相信B2指针（this）显示如下：

          d:
D* d-->      +0: pointer to virtual method table of D (for B1)
             +4: value of int_in_b1
B2* b2-->    +8: pointer to virtual method table of D (for B2)
             +12: value of int_in_b2
             +16: value of int_in_d

它已经具有该连续内存布局的起始地址的一定偏移量。例如我们想要访问b1在 D::f2() 内部，我想在运行时，它会执行类似以下操作：*(this+4) (this指向与 b2) 相同的地址，这将指向b2 in B????

我们无法通过D指向虚函数重写的指针B2::f2()，因为同一虚拟函数的所有重写必须接受相同的内存布局。

Since B2::f2()函数期望B2传递给它的对象的内存布局this指针，即

b2:
  +0: pointer to virtual method table of B2
  +4: value of int_in_b2

压倒一切的函数D::f2()也必须期待相同的布局。否则，这些功能将不再可以互换。

要了解为什么互换性很重要，请考虑以下场景：

class B2 {
public:
  void test() { f2(); }
  virtual void f2() {}
  int int_in_b2;
};
...
B2 b2;
b2.test(); // Scenario 1
D d;
d.test(); // Scenario 2

B2::test() needs to make a call of f2() in both scenarios. It has no additional information to tell it how this pointer has to be adjusted when making these calls^*. That is why the compiler passes the fixed-up pointer, so test()'s call of f2 would work both with D::f2() and B2::f2().

^* Other implementations may very well pass this information; however, multiple inheritance implementation discussed in the article does not do it.