C++虚函数表解析

C++多态的实现是基于C++的虚函数表，多态实现必须具备两个条件：
1. 实现多态的函数为虚函数
2. 父类的指针（引用）指向或（引用）子类对象
为了更好的理解下面的问题我们需要明白四个名词：静态类型，动态类型，静态绑定，动态绑定

class A{
    //...
    void func1(){
        cout << "A func1" << endl;
    }
    virtual void func2(){
        cout << "A func2" << endl;
    }
};
class B:public A{
    //...
    void func1(){
        cout << "B func1" << endl;
    }
    virtual void func2(){
        cout << "B func2" << endl;
    }
};
A *pa = new B();
B b;
A a = b;

静态类型：对象在声明时采用的类型。是在编译期确定的。如：pa的静态类型为A*。

动态类型：目前所指对象的类型。是在运行期决定的。如：pa的动态类型为B*。

静态绑定：绑定的是对象的静态类型，某特性（比如函数）依赖于对象的静态类型，发生在编译期。\
上面的实例类中函数func1执行的是静态绑定，将根据调用函数的对象的静态类型执行函数，\
pa->func1() ; 将输出 A func1

动态绑定：绑定的是对象的动态类型，某特性（比如函数）依赖于对象的动态类型，发生在运行期。
上面的实例类中func2执行的是动态绑定，它会在发生函数调用时去根据对象的实际代表的类型，对查\
找函数，pa->func2将会输出B func2

而上述实例中的对象a，将默认进行静态绑定，a.func1()输出 A func1, a.func2()输出 A func2。

与此同时，理解C++的多态，最关键的就是理解C++的虚函数表，只有满足以上两个条件的时候讨论虚\
函数才有意义，下面我们所有的讨论都是在父子类自检基于多态的继承体系中。

下面这张图是下面那个示例程序中的父类和子类的内存布局，首先，图1 表示的是父类的存储时的内存\
布局，先存储虚函数表（数组）的起始地址，在按变量的生命顺序存储变量，在虚函数表中，如果有虚析构函数\
的话先在虚函数表的第0个位置存储析构函数的地址，紧接着根据虚函数声明顺序依次存储各个虚函数。

图2 是子类继承父类后的对象存储示意图，这里我主要说一下虚函数表中虚函数的存储，首先，在有析构函数的情况下还会从表中（数组）的第0地址先存储析构函数。
然后，存储父类的虚函数，在存储子类的虚函数，存储子类虚函数的过程才是关键，由于存储子类虚函数父类虚函数已经存储完成，如果在存储子类虚函数的过程中存在父类中被子类override的virtual函数，父类中存在虚表中的函数将会被子类的覆盖，如果存储的是子类独有的函数，将接着表中空闲位置依次存储。
最后，如果是父类指针或引用实际指向的是子类对象，在指针或引用进行函数调用虚函数时，就会去对象的虚函数表中查找函数，此时，父类在虚函数表中与子类同名的函数被子类覆盖，此时将会调用子类函数，Super *p = new Sub(); p->desc();这时候desc将会调用子类的。

下面是具体代码：

#include <iostream>

using namespace std;

class Super{
public:
    char sex;
    int id;
    virtual ~Super(){}
    virtual void desc(){
        cout << "super id = " << id << endl;
        cout << "super sex = " << sex << endl;
    }
    virtual void Supervtable1(){
        cout << "Supervtable1" << endl;
    }
    virtual void Supervtable2(){
        cout << "Supervtable2" << endl;
    }
    virtual void Supervtable3(){
        cout << "Supervtable3" << endl;
    }
    void setId(int id){
        this->id = id;
    }
    void setSex(char sex){
        this->sex = sex;
    }
};

class Sub : public Super{   
public:
    int Sid;
    virtual ~Sub(){}
    virtual void desc(){
        cout << "desc" << endl;
        /*
        cout << "sub id = " << id << endl;
        cout << "sub sex = " << sex << endl;
        cout << "sub Sid = " << Sid << endl;
        */
    }
    virtual void vtable1(){
        cout << "vtable1" << endl;
    }
    virtual void vtable2(){
        cout << "vtable2" << endl;
    }
    virtual void vtable3(){
        cout << "vtable3" << endl;
    }

};

typedef void(*func)();

int _tmain(int argc, _TCHAR* argv[])
{
    Super s;

    //sizeof(pointer) == 4()
    //sizeof(char) == 1空闲3个字节(在存储int时4字节对齐) 
    //sizeof(int) == 4 
    cout << sizeof(s) << endl; //12 

    cout << &s << endl;   //存储的是虚表指针
    printf("%08x\n", (int)&s.sex);
    cout << &s.id << endl;


    Sub sb;

    cout << sizeof(sb) << endl;
    cout << &sb << endl;  //存储虚表指针
    printf("%08x\n", (int)&sb.sex);
    cout << &sb.id << endl;
    cout << &sb.Sid << endl;

    //虚函数表的起始地址
    unsigned int *vptr = (unsigned int *)(*((unsigned int *)(&sb)));
    //把虚函数表转换为对应的指针数组
    //这里只考虑函数相同的情况，如果函数不同要分开做类似转换
    func *fvptr = (func *)vptr;

    fvptr[1](); //desc
    fvptr[2](); //Supervtable1
    fvptr[3](); //Supervtable2
    fvptr[4](); //Supervtable3
    fvptr[5](); //vtable1
    fvptr[6](); //vtable2
    fvptr[7](); //vtable3

    system("pause");
    return 0;
}

程序输出结果如下图：