【转】C++动态绑定和虚函数表vtable （动态实现原理）

 关于C++内部如何实现多态，对程序员来说即使不知道也没关系，但是如果你想加深对多态的理解，写出优秀的代码，那么这一节就具有重要的意义。 我们知道，函数调用实际上是执行函数体中的代码。函数体是内存中的一个代码段，函数名就表示该代码段的首地址，函数执行时就从这里开始。说得简单一点，就是必须要知道函数的入口地址，才能成功调用函数。

• 找到函数名对应的地址，然后将函数调用处用该地址替换，这称为函数绑定，或符号决议。

• 一般情况下，在编译期间（包括链接期间）就能完成符号决议，不用等到程序执行时再进行额外的操作，这称为静态绑定。如果编译期间不能完成符号决议，就必须在程序执行期间完成，这称为动态绑定。

非虚成员函数属于静态绑定：编译器在编译期间，根据指针（或对象）的类型完成了绑定。

而对于虚函数，知道指针的类型也无济于事。假设 func() 为虚函数，p 的类型为 A，那么 p->func() 可能调用 A 类的函数，也可能调用 B、C 类的函数，不能根据指针 p 的类型对函数重命名。也就是说，虚函数在编译期间无法绑定。

单一继承

虚函数表 vtable

如果一个类包含了虚函数，那么在创建对象时会额外增加一张表，表中的每一项都是虚函数的入口地址。这张表就是虚函数表，也称为 vtable。 可以认为虚函数表是一个数组。 为了把对象和虚函数表关联起来，编译器会在对象中安插一个指针，指向虚函数表的起始位置。
例如对于下面的继承关系：

class A {
protected:
  int a1;
  int a2;

public:

  virtual void display() {
    cout << "A::display()";
  }

  virtual void clone() {
    cout << "A::clone()";

  }
};

class B : public A {

protected:
  int b;

public:

  virtual void display() {
    cout << "B::display()";
  }

  virtual void init() {
    cout << "B::init()";

  }
};

class C : public B {

protected:
  int c;

public:

  virtual void display() {
    cout << "C::display()";
  }

  virtual void execute() {
    cout << "C::execute()";
  }
};

各个类的内存分布如下所示：

  通过上图可以发现，对于单继承，不管继承层次有多深，只需要增加一个指针即可，不会随着继承层次的加深让对象背负越来越多的指针。而且，基类中的虚函数在 vtable 中的索引是固定的，不会随着继承层次的增加而改变，例如 display() 的索引值始终是 0。当调用虚函数时，借助指针 vfptr 完成一次间接转换，就可以得到虚函数的入口地址。
对于虚函数 display()，它在 vtable 中的索引为 0，发生调用时：
p->display();

编译器内部会发生转换，产生类似下面的代码：
( *( p->vptr )[0] ) (p); //*( p->vptr )[0]是函数入口地址

这条语句没有用到与指针 p 的类型有关的信息，也没有用到 Name Mangling 算法。程序运行后会执行这条语句，完成函数的调用，这就是动态绑定。

编译器在编译期间会备足各种信息，并完成相应的转换，程序运行后只需要执行简单的代码就能找到函数入口地址，进而调用函数。

init() 函数在 vtable 中的索引为 2，发生调用时：
p->init();

编译器内部的转换为：
( *( p->vptr )[2] ) (p);

对于不同的虚函数，仅仅改变索引值即可。

当派生类有多重继承时，虚函数表的结构会变得复杂，尤其是有虚继承时，还会增加虚基类表，更加让人抓狂，这里我们就不分析了，有兴趣的读者可以自行研究。

（1）派生类完全拥有基类的内存布局，并保证其完整性。

  派生类可以看作是完整的基类的Object再加上派生类自己的Object。如果基类中没有虚成员函数，那么派生类与具有相同功能的非派生类将不带来任何性能上的差异。另外，一定要保证基类的完整性。实际内存布局由编译器自己决定，VS里，把虚指针放在最前边，接着是基类的Object，最后是派生类自己的object。举个栗子：

class A
{
    int b;
    char c;
};
class A1 :public A
{
        char a;
};
int main()
{
    cout << sizeof(A) << " " << sizeof(A1) << endl;
    return 0;
}

输出是什么？
答案：8 12
  A类的话，一个int，一个char，5B，内存对齐一下，8B。A1的话，一个int，两个char，内存对齐一下，也是8B。不对吗？
  我说了，要保证基类对象的完整性。那么一定要保证A1类前面的几个字节一定要与A类完全一样。也就是说，A类作为内存补齐的3个字节也是要出现在A1里面的。也就是说，A类是这样的：int(4B)+char(1B)+padding(3B)=8B，A1类：int(4B)+char(1B)+padding(3B)+char(1B)+padding(3B)=12B。

（2）虚指针怎么处理？

  还是视编译器而定，VS是永远把vptr放在对象的最前边。如果基类中含有虚函数，那么处理情况与上边一样。可是，如果基类中没有虚函数而派生类有的话，那么如果把vptr放在派生类的前边的话，将会导致派生类中基类成分并不在最前边。这将带来什么问题呢？举栗：假设A不含虚，而A1含。

A *pA;
A1 obj_A1;
pA=&obj_A1;

果A1完全包含A并且A位于A1的最前边，那么编译器只需要把&obj_A1直接赋给pA就可以了。如果不是呢？编译器就需要把&obj_A1+sizeof(vptr)赋给pA了。

2 多重继承

说结论：VS的内存布局是按照声明顺序排列内存。再举个栗子：

class point2d
{
public:
    virtual ~point2d(){};
    float x;
    float y;
};
class point3d :public point2d
{
    ~point3d(){};
    float z;
};
class vertex
{
public:
    virtual ~vertex(){};
    vertex* next;
};
class vertex3d :public point3d, public vertex
{
    float bulabula;
};


int _tmain(int argc, _TCHAR* argv[])
{
    cout << sizeof(point2d) << " " << sizeof(point3d) << " " << sizeof(vertex) << " " << sizeof(vertex3d) << endl;
    return 0;
}

输出： 12 16 8 24。

内存布局：

point2d: vptr(4)+x(4)+y(4)=12B

point3d: vptr+x+y+z=16B

vertex: vptr+next=8B

vertex3d: vptr+x+y+z+vptr+next+bulabula=28B

为什么需要多个虚指针？请往下看。

3 虚拟继承

（1）为什么要有“虚继承”这样的机制？

  简单讲，虚继承是为也防止“diamond”继承所带来的问题。也就是类A1、A2都继承于A，类B又同时继承于A1、A2。这样一来，类B中就有两份类A的成员了，这样的程序无法通过编译。我们改成这样的形式：

class A
{
public:
　　int a;
　　virtual ~A(); 
    virtual void fun(){cout<<"A"<<endl;}
};
class A1 :public virtual A
{
public:
　　int a1;
   virtual void fun(){cout<<"A1"<<endl;}
};
class A2 :public virtual A
{
public:
　　int a2;
   virtual void fun(){cout<<"A2"<<endl;}
}; 

class B :public A1,public A2 {
public:
　　int b;
    virtual void fun(){cout<<"B"<<endl;}
    virtual void funB(){};
};

这样就能防止这样的事情发生。

（2）虚拟继承与普通继承的区别：

  普通继承使得派生类每继承一个基类便拥有一份基类的成员。而虚拟继承会把通过虚拟继承的那一部分，放在对象的最后。从而使得只拥有一份基类中的成员。虚拟对象的偏移量被保存在Derived类的vtbl的this指向的上一个slot。比较难理解。下面我给你个栗子。

（3）虚拟继承的内存布局：

每个派生类会把其不变部分放在前面，共享部分放在后面。

上面四个类的大小是怎样的呢？

int _tmain(int argc, _TCHAR* argv[])
{
    cout << sizeof(A) << " " << sizeof(A1) << " " << sizeof(A2) << " " << sizeof(B) << endl;
    return 0;
}

输出：8 16 16 28

内存布局：

A: vptr+a=8B

A1: vptr+a1+vptrA+a=16B

A2: vptr+a2+vptrA+a=16B

A3: vptr+a1+vptrA2+a2+b+vptrA+a=28B

上个草图：

那究竟为什么需要多个虚指针？将对象内存布局和虚表结构搞清楚之后，答案是不是呼之欲出呢？

  是的，因为这样可以保证在将子类指针/引用转换成基类指针时编译器可以直接根据对像的内存布局进行偏移，从而使得指向的第一个内容为虚指针，进而实现多态（根据静态类型执行相应动作）。