解析动态联编(下)

  三 虚函数表VTABLE

   动态联编过程跟 我们猜测的大致相同。编译器在执行过程中遇到virtual关键字的时候，将自动安装动态联编需要的机制，首先为这些包含virtual函数的类（注意不 是类的实例）--即使是祖先类包含虚函数而本身没有--建立一张虚拟函数表VTABLE。在这些虚拟函数表中，编译器将依次按照函数声明次序放置类的特定 虚函数的地址。同时在每个带有虚函数的类中放置一个称之为vpointer的指针，简称vptr，这个指针指向这个类的VTABLE。
   关于虚拟函数表，有几点必须声明清楚：
1. 每一个类别只能有一个虚拟函数表，如果该类没有虚拟函数，则不存在虚拟函数表。
2. C++编译时候编译器会在含有虚函数的类中加上一个指向虚拟函数表的指针vptr。
3. 从一个类别诞生的每一个对象，将获取该类别中的vptr指针，这个指针同样指向类的VTABLE。

   因此类、对象、VTABLE的层次结构可以用下图表示。其中X类和Y类的对象的指针 都指向了X,Y的虚拟函数表，同时X,Y类自身也包含了指向虚拟函数的指针。
 
   为了方便问题说明，我们将2.cpp例子进行扩展，扩展程序如下。

   
   
   
   

    
    
    
    
 
      
     // 
     4.cpp 
     
 
     15 
     . ＃include  
     < 
     iostream.h  
     > 
     
 
     16 
     .  
     class 
      shape 
     ... 
     {
17.  public:
18.    virtual void draw()...{cout<<"shape::draw()"<<endl;}
19.    virtual void area()...{cout<<"shape::area()"<<endl;}
20.    void fun()...{draw();area();}
21. } 
     ;
 
     22 
     .  
     class 
      circle: 
     public 
      shape 
     ... 
     {
23.  public:
24.    void draw()...{cout<<"circle::draw()"<<endl;}
25.    void adjust()...{cout<<"circle::adjust()"<<endl;}
26. } 
     ;
 
     27 
     . int main() 
     ... 
     {
28.    shape oneshape;
29.    oneshape.fun();
30.    
31.    circle  circleshape;
32.    shape&  baseshape=circleshape;
33.    baseshape.fun();
34. } 
    
   
   
   
   

   编译器在编译上面这段代码的时候将为这shape和circle两个对象分别建立一个VTABLE表，这些表依次填充派生类对象和基类对象中声明的所有的 虚函数地址。如果派生类本身没有重新定义基类的虚函数，那么填充的就是基类的虚函数地址。这样一旦如果函数调用一个派生类不存在的方法时候能够自动调用基 类方法。然后编译器在每个类中放置一个vptr，一般置于对象的起始位置，继而在对象的构造函数中将vptr初始化为本类的VTABLE的地址。整个结果 布局如下。

                                图一

   图一中的rectangle的VTABLE中的area() 和triangle的VTABLE的adjust()都是填充的基类的虚函数地址。 C++ 编译程序时候按下面的步骤进行工作:
①为各类建立虚拟函数表，如果没有虚函数则不建立。
②暂时不连接虚函数，而是将各个虚函数的地址放入虚拟函数表中。
③直接连接各静态函数。
   这些工作做完之后，模块图如图二：

                                         图二

   执 行时候，诞生了oneshape和circleshape两个对象，oneshape对象的vptr指针指向shape的VTABLE， circleshape对象的vptr指针指向circleshape的VTABLE，在执行oneshape.fun()的时候，fun函数的this 指针指向了oneshape对象，进入fun()之后程序继续执行this->draw()，由于this指向oneshape对象， oneshape的vptr又指向shape类的VTABLE，这样就从VTABLE中得到需要绑定的函数的地址，并连接起来。同样，this-> area()也经由oneshape对象而连接到相应的函数上，如图三。

                                          图三

   现在我们执行baseshape.fun()函数。

circle  circleshape;
shape&  baseshape=circleshape;
baseshape.fun();

   函数进入fun函数之后，函数的this指针将指向basefun对象，另一方面basefun指向一个circleshape，因此this指针指向的 实际上为circleshape对象，而circleshape的vptr指针指向circle类的虚拟函数表，这样编译器将从虚拟表中取出 circle::draw()和circle::area()的地址，进行连接。因为circle本身没有重新定义area()方法，因此编译器使用 shape的area()方法。如图四。

                                       图四

   遵循上面的思路，基于基类的指针总能找到正确的子类对象的实现。但是象上面的 this->draw是怎么编译的呢。

四 编译内幕

   在 上面的程序中，this指针不同，从而连接到不同的fun函数。那么C++如何编译这些指令呢。道理在于：所有的基类的派生类的虚拟函数表的顺序与基类的 顺序是一样的，对于基类中不存在方法再按照声明次序进行排放。这样不管是shape还是circle或者从shape又继承出来的其余的类它们的虚拟函数 表的第一项总是draw函数的地址，然后是area的地址。对于circle类，下面的才是adjust的地址。因此不管对于shape还是 circle，this->draw总是编译成 call this->VTABLE[0]; this->area()总是翻译成 call this->VTABLE[1]; 程序到真正运行时候将会发现this的真正指向的对象，如果是shape,则调用shape->VTABLE[0]，如果是circle，则调用 circle->VTABLE[1]，如图五。

                                     图五

请看下面的这个例子。

   
   
   
   

    
    
    
    
 
      
     35 
     . ＃i nclude 
 
     36 
     .  
     class 
      shape 
     ... 
     {
37.  public:
38.    virtual void draw()...{cout<<"shape::draw()"<draw();//OK
51.    oneshape->adjust();//错误,编译器无法通过
52.    
53.    circle* circleshape;
54.    circleshape->adjust();
55. } 
    
   
   
   
   

    在程序编译期间，由于oneshape为shape类型的，因此它将检查shape的虚拟函数表，发现VTABLE[0]为
draw函数的地址，于 是翻译成p->VTABLE[0]。未来执行期间，p 实际上指向的是circle对象，因此真正调用
的为circle->VTABLE[0]处的函数，即circle::draw。同样对于 adjust函数，C++ 编译器也会去检查shape的
VTABLE，结果编译器无法找到adjust函数，因此编译无法通过。 对于circleshape，因为它是circleshape类型
的，因此它将会检查circle的VTABLE,得知VTABLE[2]处为 adjust的地址，因此编译器翻译成
call circleshape->VTABLE[2]，真正执行时候circleshape为circle类型，因此它将绑定circle的VTABLE [2]处
的函数即circle:: adjust()。 就这样，编译器借助虚拟函数表实现了动态联编的过程，从而使多态的实现有了
可能。因此说虚拟函数表是多态性的幕后功臣一点也不为过。