虚方法的调用是怎么实现的(单继承VS多继承)

我们知道通过一个指向之类的父类指针可以调用子类的虚方法，因为子类的方法会覆盖父类同样的方法，通过这个指针可以找到对象实例的地址，通过实例的地址可以找到指向对应方法表的指针，而通过这个方法的名字就可以确定这个方法在方法表中的位置，直接调用就行，在多继承的时候，一个类可能有多个方法表，也就有多个指向这些方法表的指针，一个类有多个父类，怎么通过其中一个父类的指针调用之类的虚方法？

其实前面几句话并没有真正说清楚，在单继承中，父类是怎么调用子类的虚方法的，还有多继承又是怎么实现这点的，想知道这些，请认真往下看。

我们先看单继承是怎么实现的。先上两个简单的类：

#include <iostream> 
using namespace std; class A
{
public:A():a(0){}virtual ~A(){}virtual void GetA(){cout<<"A::GetA"<<endl; }void SetA(int _a){a=_a; } int a;
};class B:public A
{
public:B():A(),b(0){}virtual ~B(){}virtual void GetA(){ cout<<"B::GetA"<<endl; }virtual void GetB(){ cout<<"B::GetB"<<endl; }
private:int b;
};typedef int (*Fun)(void);void TestA()
{Fun pFun;A a; cout<<"类A的虚方法（第0个是A的析构函数）："<<endl;int** pVtab0 = (int**)&a;for (int i=1; (Fun)pVtab0[0][i]!=NULL; i++){ pFun = (Fun)pVtab0[0][i]; cout << "    ["<<i<<"] "; pFun(); }cout<<endl;B b ;A* b1=&b;cout<<"类B的虚方法（第0个是B的析构函数）通过类B的实例："<<endl;int** pVtab1 = (int**)&b;for (int i=1; (Fun)pVtab1[0][i]!=NULL; i++){ pFun = (Fun)pVtab1[0][i]; cout << "    ["<<i<<"] "; pFun(); }cout<<endl;cout<<"类B的虚方法（第0个是B的析构函数）通过类A的指针："<<endl;int** pVtab2 = (int**)&*b1;for (int i=1; (Fun)pVtab2[0][i]!=NULL; i++){ pFun = (Fun)pVtab2[0][i]; cout << "    ["<<i<<"] "; pFun(); }cout<<endl;cout<<"     b的地址："<<&b<<endl;cout<<"b1指向的地址："<<b1<<endl<<endl;
}

运行结果如下：

通过运行结果我们知道：通过父类指向子类的指针调用的是子类的虚方法。在单一继承中，虽然父类有父类的虚方法表，子类有子类的虚方法表，但是子类并没有指向父类虚方法的指针，在子类的实例中，子类和父类是公用一个虚方法表，当然只有一个指向方法表的指针，为什么可以公用一个虚方法表呢，虚方法表的第一个方法是析构函数，子类的方法会覆盖父类的同样的方法，子类新增的虚方法放在虚方法表的后面，也就是说子类的虚方法表完全覆盖父类的虚方法表，即子类的每个虚方法与父类对应的虚方法，在各种的方法表中的索引是一样的。

但是在多继承中就不是这样了，第一个被继承的类使用起来跟单继承是完全一样的，但是后面被继承的类就不是这样了，且仔细往下看。

还是先上3个简单的类

#include <iostream> 
using namespace std; class A
{
public:A():a(0){}virtual ~A(){}virtual void GetA(){cout<<"A::GetA"<<endl; }int a;
};class B 
{
public:B():b(0){}virtual ~B(){}virtual void SB(){ cout<<"B::SB"<<endl; } virtual void GetB(){  cout<<"B::GetB"<<endl; }private:int b;
};class C:public A,public B 
{
public:C():c(0){}virtual ~C(){}virtual void GetB()//覆盖类B的同名方法
    { cout<<"C::GetB"<<endl; }virtual void GetC(){ cout<<"C::GetC"<<endl; }virtual void JustC(){cout<<"C::JustC"<<endl; }
private:int c;
};typedef int (*Fun)(void);void testC()
{C* c=new C();A* a=c;B* b=c;Fun pFun;cout<<"sizeof(C)="<<sizeof(C)<<endl<<endl;cout<<"c的地址："<<c<<endl;cout<<"a的地址："<<a<<endl;cout<<"b的地址："<<b<<endl<<endl<<endl;cout<<"类C的虚方法(第0个是C的析构函数)(通过C类型的指针)："<<endl;int** pVtab1 = (int**)&*c;for (int i=1; (Fun)pVtab1[0][i]!=NULL; i++){ pFun = (Fun)pVtab1[0][i]; cout << "    ["<<i<<"] "<<&*pFun<<"    "; pFun(); }cout<<endl<<endl;cout<<"类C的虚方法(第0个是C的析构函数)(通过B类型的指针)："<<endl;pVtab1 = (int**)&*b;for (int i=1; (Fun)pVtab1[0][i]!=NULL; i++){ pFun = (Fun)pVtab1[0][i]; cout << "    ["<<i<<"] "<<&*pFun<<"    "; pFun(); }
}

运行结果如下：

从结果说话：

Sizeof(C)=20,我们并不意外，在单继承的时候，父类和子类是公用一个指向虚方法表的指针，在多继承中，同样第一个父类和子类公用这个指针，而从第二个父类开始就有自己单独的指针，其实就是父类的实例在子类的内存中保持完整的结构，也就是说在多重继承中，之类的实例就是每一个父类的实例拼接而成的，当然可能因为继承的复杂性，会加一些辅助的指针。

指针a与指针c指向同一个地址，即c的首地址，而b所指的地址与a所指的地址相差8字节刚好就是类A实例的大小，也就是说在C的内存布局中，先存放了A的实例，在存放B的实例，sizeof(B)=8（字段int b和指向B虚方法表的指针），在家上C自己的字段int c刚好是20字节。

让我有点意外的是：方法B::SB，C::GetB并没有出现在类C的方法表中，而且C::GetB是C覆写B中的GetB方法，怎么没有出现在C的方法表中呢？在《深入探索C++对象模型》一书中讲到，这两个方法同时应该出现在C的方法表中，同样也会覆盖B的虚方法表。可能是不通的编译器有不同的实现，我用的是VS2010，那本书上讲的是编译器cfront

OK，我们不用管不同的编译器实现上的区别，这点小区别无伤大雅，虚方法的调用机制还是一样的。

先来分析几个小例子，看看虚方法的实现机制。

C* c=new C();

A* a=c;

a->GetA();

c->GetA();

c->GetC();

上面已经说了，a与c指向的是同一个地址，且公用同一个虚方法表，而方法GetA，GetC的地址就在这个方法表中，那么调用起来就简单多了，大致就是下面这个样子：

a->GetA()   －＞   (a->vptr1[1])(a);   // GetA在方法表中的索引是1

c->GetA()  －＞  (c->vptr1[1])(c);   // GetA在方法表中的索引是1

c->GetC()   －＞   (a->vptr1[2])(c);   // GetC在方法表中的索引是2

vptr1表示指向类C第一个方法表的指针，这个指针实际的名字会复杂一些，暂且将指向类C的第一个方法表的指针命名为vptr2，下面会用到这个指针。

再来分析几行代码：

B* b=c;

c->GetB();

b->GetB();

指针b和指针c指向的不是同一个地址，那么B* b=c;到底是做了啥呢？大致是会转换成下面这个样子：

B* b=c+sizeof(A);

c所指的地址加上A的大小，刚好是b所指的地址。

c->GetB();同样需要转换，因为方法GetB根本不在c所指的那个方法表中，可能转换成这个样子(实际转换成啥样子我真不知道)：

this=c+sizeof(A);

(this->vptr2[2])(c);

如果像编译器cfront所说的那样，方法GetB在vptr1所指的方法表中，那么就不用产生调整this指针了，如果在vptr1所指的方法表中，就让方法表变大了，且跟别的方法表是重复的。

b->GetB();就不需要做过多的转换了，因为b正好指向vptr2，可能转换成下面这个样子：

b->GetB()   －＞   (b->vptr2[2])(b);   // GetB在方法表中的索引是2

总之指针所指的方法表如果没有要调用的方法，就要做调整，虚方法需要通过方法表调用，相对于非虚方法，性能就慢那么一点点，这也是别人常说的C++性能不如C的其中一点。

虚多继承就更麻烦了，不熟悉可能就会被坑。《深入探索C++对象模型》这本书是这样建议的：不要在一个virtual base class中声明nonstatic data members，如果这样做，你会距复杂的深渊越来越近，终不可拔。

virtual base class还是当做接口来用吧。