C++虚函数表

C++通过虚函数来实现多态，也就是让父类指针指向子类，在运行时根据指针指向的对象的实际类型来确定调用子类或者父类中的某个函数。

class Base
{
public :
    virtual void f() { cout<<"Base::f()"<<endl ; }
    virtual void g() { cout<<"Base::g()"<<endl ; }
    virtual void h() { cout<<"Base::h()"<<endl ; }
} ;

class Derive : public Base
{
public :
    void f() { cout<<"Derive::f()"<<endl ; }
    virtual void g() { cout<<"Derive::g()"<<endl ; }
    virtual void i() { cout<<"Derive::i()"<<endl ; }
    void j() { cout<<"Derive::j()"<<endl ; }
} ;

int main()
{
    Base* b = new Derive() ;
    b->f()  ;
    b = new Base() ;
    b->f() ;
    return 0 ;
}

上面定义了父类 Base 和它的子类 Derive ，定义了父类类型的指针，使其先后指向一个Derive对象和Base对象，调用f().输出如下：

Derive::f()

那是如何确定调用哪个函数的呢？为了确定正确的调用函数，一种常用的实现技术是让编译器把一个virtual函数的名字转换为指向这些函数的指针表的一个下标（引用自C++程序设计语言），这个表就是虚函数表(简称vtb)，vtb是一个静态的一维数组，数组元素是函数指针, 通过这些指针可以调用对应的函数。

vtb的地址一般保存在对象的最开始的位置，就拿上面的代码举例，Base类型对象的vtb的地址为

typedef void(*fun)(void)

Base b ;

(long*)*(long*)&b//对象 b 的 vtb 的地址

从而可以通过vtb表调用函数

cout<<"address of vtb's address"<<(long*)&b<<endl ;
cout<<"address of vtb"<<(long*)*(long*)&b<<endl ;
cout<<"address of first function in object"<<(fun)*(long*)*(long*)&b<<endl ;

((fun)*(long*)*(long*)&b)() ;
((fun)*((long*)*(long*)&b+1))() ;
((fun)*((long*)*(long*)&b+2))() ;

需要注意的是，vtb中函数地址的次序与类中函数声明的次序是一致的，对于子类，父类的函数地址在子类的前面，如果子类重写了父类的虚函数，不管重写后的函数是否还是虚函数，也不管子类的这个函数声明在什么位置，在子类对象的vtb中，该重写的函数的地址会取代父类被重写函数的地址。

当出现多继承时，子类对象会有多个vtb，在对象开始处也会有多个vtb表的地址，即对象开始处也有一个一维数组，数组元素是vtb表的地址。

#include<iostream>

using namespace std ;

class Base1
{
public :
    virtual void f() { cout<<"Base1::f()"<<endl ; }
    virtual void g() { cout<<"Base1::g()"<<endl ; }
    virtual void h() { cout<<"Base1::h()"<<endl ; }
    virtual void b1() { cout<<"Base::b1()"<<endl ; }
} ;

class Base2
{
public :
    virtual void f() { cout<<"Base2::f()"<<endl ; }
    virtual void g() { cout<<"Base2::g()"<<endl ; }
    virtual void h() { cout<<"Base2::h()"<<endl ; }
    virtual void b2() { cout<<"Base::b2()"<<endl ; }
} ;

class Base3
{
public :
    virtual void f() { cout<<"Base3::f()"<<endl ; }
    virtual void g() { cout<<"Base3::g()"<<endl ; }
    virtual void h() { cout<<"Base3::h()"<<endl ; }
    virtual void b3() { cout<<"Base::b3()"<<endl ; }
} ;

class Derive : public Base1 , Base2 , Base3
{
public :
    void f() { cout<<"Derive::f()"<<endl ; }
    virtual void g() { cout<<"Derive::g()"<<endl ; }
    virtual void i() { cout<<"Derive::i()"<<endl ; }
    void j() { cout<<"Derive::j()"<<endl ; }
    void b1() { cout<<"Derive::b1()"<<endl ; }
    void b2() { cout<<"Derive::b2()"<<endl ; }
    void b3() { cout<<"Derive::b3()"<<endl ; }
} ;

typedef void(*fun)(void) ;

int main()
{
    Derive d = Derive() ;
    
    cout<<"address of vtb1's address:"<<(long*)&d<<endl ;
    cout<<"address vtb1:"<<(long*)*(long*)&d<<endl ;
    cout<<"address of first function in vtb1:"<<(fun)*(long*)*(long*)&d<<endl ;
    ((fun)*((long*)*(long*)&d + 0))() ;
    ((fun)*((long*)*(long*)&d + 1))() ;
    ((fun)*((long*)*(long*)&d + 2))() ;
    ((fun)*((long*)*(long*)&d + 3))() ;
    ((fun)*((long*)*(long*)&d + 4))() ;
    ((fun)*((long*)*(long*)&d + 5))() ;
    ((fun)*((long*)*(long*)&d + 6))() ;
    //((fun)*((long*)*(long*)&d + 7))() ;
    
    cout<<"address of vtb2's address:"<<(long*)&d<<endl ;
    cout<<"address vtb2:"<<(long*)*(long*)&d<<endl ;
    cout<<"address of first function in vtb2:"<<(fun)*(long*)*(long*)&d<<endl ;
    ((fun)*((long*)*((long*)&d + 1) + 0))() ;
    ((fun)*((long*)*((long*)&d + 1) + 1))() ;
    ((fun)*((long*)*((long*)&d + 1) + 2))() ;
    ((fun)*((long*)*((long*)&d + 1) + 3))() ;
    
    cout<<"address of vtb3's address:"<<(long*)&d<<endl ;
    cout<<"address vtb3:"<<(long*)*(long*)&d<<endl ;
    cout<<"address of first function in vtb3:"<<(fun)*(long*)*(long*)&d<<endl ;
    ((fun)*((long*)*((long*)&d + 2) + 0))() ;
    ((fun)*((long*)*((long*)&d + 2) + 1))() ;
    ((fun)*((long*)*((long*)&d + 2) + 2))() ;
    ((fun)*((long*)*((long*)&d + 2) + 3))() ;
    
    return 0 ;
}

参考：http://blog.csdn.net/haoel/article/details/1948051