C++虚函数机制

1.1      简介

编译器对每个包含虚函数的类创建一个表（称为VTABLE）。在VTABLE中，编译器放置特定类的虚函数地址。在每个带有虚函数的类中，编译器秘密地置一指针，称为vpointer（缩写为VPTR），指向这个对象的VTABLE。通过基类指针做虚函数调用时（也就是做多态调用时），编译器静态地插入取得这个VPTR，并在VTABLE表中查找函数地址的代码，这样就能调用正确的函数使晚捆绑发生。为每个类设置VTABLE、初始化VPTR、为虚函数调用插入代码，所有这些都是自动发生的。利用虚函数，这个对象的合适的函数就能被调用，哪怕在编译器还不知道这个对象的特定类型的情况下。（《C++编程思想》）

class no_virtual {

public:

    void fun1() const{}

    int  fun2() const { return a; }

private:

    int a;

}

class one_virtual {

public:

    virtual void fun1() const{}

    int fun2() const { return a; }

private:

    int a;

}

class two_virtual {

public:

    virtual void fun1() const{}

    virtual int fun2() const { return a; }

private:

    int a;

}

 

以上三个类中：

no_virtual没有虚函数，sizeof(no_virtual)=4，类no_virtual的长度就是其成员变量整型a的长度；

one_virtual有一个虚函数，sizeof(one_virtual)=8；

two_virtual有两个虚函数，sizeof(two_virtual)=8；有一个虚函数和两个虚函数的类的长度没有区别，其实它们的长度就是no_virtual的长度加一个void指针的长度，它反映出，如果有一个或多个虚函数，编译器在这个结构中插入一个指针(VPTR)。在one_virtual和two_virtual之间没有区别，因为只需要一个指针VPTR，它指向一个存放地址的表所有虚函数地址都包含在这个表中。这个VPTR就可以看作类的类型信息。

1.2      理解虚函数的一个实例

typedef void(*Fun)(void);

class Base{

public:

    void bfun(){}

    virtual void vfun1(){ cout << "Base::vfun1()" << endl; }

    virtual void vfun2(){cout << "Base::vfun2()" << endl;  }

private:

    int a;

};

class Derived : public Base{

public:

    void dfun(){}

//在派生类(子孙都包括)中也是虚函数，即使不再使用virtual关键字：

    void vfun1(){ cout << "Derived::vfun1()" << endl; }

    virtual void vfun3(){}

private:

    int b;

};

int main(int argc, char* argv[]){

    Base b;

    Fun pFun = NULL;

    cout << "虚函数表地址: " << (int*)(&b) << endl;

    cout << "虚函数表第一个函数地址: " << (int*)*(int*)(&b) << endl;

    cout << "虚函数表第二个函数地址: " << (int*)*(int*)(&b)+1 << endl;

    // Invoke the first virtual function

    pFun = (Fun)*((int*)*(int*)(&b));  //1）

    pFun();

    Derived td;

    Base *pb = &td;

    pb->vfun2();                  //2）

    return 0;

}

1）两个类VPTR指向的虚函数表(VTABLE)分别如下：

base类：

            ——————

VPTR——>  |&base::vfun1 |

            ——————

            |&base::vfun2 |

            ——————

derived类：

            ———————

VPTR——>  |&derived::vfun1 |

            ———————

            |&base::vfun2   |

            ———————

            |&derived::vfun3 |

            ———————

derived::vfun1的地址覆盖了base::vfun1的地址，这也就是为什么override翻译成覆盖的原因了。

在VTABLE中，编译器放置了在这个类中或在它的基类中所有已声明为virtual的函数的地址。如果在这个派生类中没有对在基类中声明为virtual的函数进行重新定义，编译器就使用基类的这个虚函数地址(vfun2的入口就是这种情况)，然后编译器在这个类中放置 VPTR。当使用简单继承时，对于每个对象只有一个VPTR（如果是多继承则一个类会有多个VTABLE）。VPTR被初始化为指向相应的VTABLE是在构造函数中发生的。

在C++的标准规格说明书中说到，编译器必需要保证虚函数表的指针存在于对象实例中最前面的位置(这是为了保证正确取到虚函数的偏移量)。VPTR总指向VTABLE的开始地址，所有基类和它的子类的虚函数地址(子类自己定义的虚函数除外)在VTABLE中存储的位置总是相同的，如上面base类和derived类的VTABLE中vfun1和 vfun2。编译器知道vfun1位于VPTR处，vfun2位于VPTR+1处，因此在用基类指针调用虚函数时，编译器首先获取指针指向对象的类型信息（VPTR），然后就去调用虚函数。如一个base类指针pBase指向了一个derived对象，那 pBase->vfun2()被编译器翻译为 VPTR+1 的调用，因为虚函数vfun2的地址在VTABLE中位于索引为1的位置上。同理，pBase->vfun3()被编译器翻译为 VPTR+2的调用。

       通过上面的分析可知，调用Base类虚函数的方法可以这样：

(Fun)*((int*)*(int*)(&b)+0);   // Base::vfun1()

(Fun)*((int*)*(int*)(&b)+1);   // Base:: vfun2()

 

2）若是普通函数调用只需要一条call指令就可以。而语句pb->vfun2(); 的反汇编代码如下所示：（VC6.0）

       004011C6   mov  ecx,dword ptr [ebp-10h]  // ecx就是指针VPTR

004011C9   mov  edx,dword ptr [ecx]   // edx取Derived对象头部四个字节

004011CB   mov  esi,esp

004011CD   mov  ecx,dword ptr [ebp-10h]

004011D0   call   dword ptr [edx+4]    //调用了Derived对象头部第二个个函数指针，即Derived::vfun2

004011D3   cmp   esi,esp

004011D5   call    __chkesp (00409350)

1.3      虚析构函数

当一个类打算被用作其它类的基类时，它的析构函数应当是虚的：

class A{

public:

     A() { ptra_ = new char[10];}

     ~A() { delete[] ptra;} //应设为虚析构函数virtual ~A() { delete[] ptra;}

private:

     char * ptra;

};

class B: public A{

public:

     B() { ptrb_ = new char[20];}

     ~B() { delete[] ptrb;}

private:

     char * ptrb;

};

void foo(){

     A * a = new B;

     delete a;

}

   在执行delete a的时候，实际上只有A::~A()被调用了，而B类的析构函数并没有被调用。因此，派生类的析构函数没有被调用，ptrb所指的内存没有被释放。因此，基类的析构函数应当被设为虚函数。

1.4      其它

一个类的虚函数在它自己的构造函数和析构函数中被调用的时候，它们就变成普通函数了，不“虚”了。也就是说不能在构造函数和析构函数中让自己“多态”(因为对象在创建完毕后才拥有VPTR，才能多态，析构函数应当类似)。例：

class A{

public:

     A() { foo();}         // 在这里，无论如何都是A::foo()被调用

     ~A() { foo();}        // 同上

     virtual void foo(){ }

};

class B: public A {

public:

     void foo(){}

};

void bar(){

     A * a = new B;

     delete a;              //

}

    如果你希望delete a的时候，会导致B::foo()被调用，那么你就错了。同样，在new B的时候，A的构造函数被调用，但是在A的构造函数中，被调用的是A::foo()而不是B::foo()。

转至：http://blog.csdn.net/starryheavens/article/details/4549616