虚函数表再学习

测试环境：编译器gcc，环境WIN7，64位系统

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

结论：1. 虚函数指针存储在类其他成员之前

          2. 基类的虚函数表、子类的虚函数表是分别存放的

          3. 子类虚函数表中存储的内容依次为：继承自基类的虚函数（按声明顺序存放）、子类自己的虚函数（按声明顺序存放）；

          4. 即使子类没有自己的虚函数，他仍然会创建一个虚函数指针以及虚函数表，虚函数表内容与父类相同，但存放地址不同。

          5. 当有覆盖发生时，子类虚函数表更新，基类不变。

首先是验证代码：

#include <iostream>

using namespace std;

class A {
    virtual void a(){cout << "A:a" <<endl;}
    virtual void b(){cout << "A:b" <<endl;}
    virtual void c(){cout << "A:c" <<endl;}
};

class AA :public A {
    void a(){cout << "AA:a" <<endl;}
    virtual void aa(){cout << "AA:aa" <<endl;}
    virtual void bb(){cout << "AA:bb" <<endl;}
};
class AAA : public AA {
};
int main()
{
    typedef void (*Fun)(void);
    A a ;
    AA aa ;
    AAA aaa ;
    Fun pFun = NULL;
    cout<<"address: "<< (int*)(&a) << endl;
    cout<<"ap: "<< (int*)*(int*)(&a) << endl;
    cout<<"address: "<< &aa << endl;
    cout<<"aap: "<< (int*)*(int*)(&aa) << endl;
    cout<<"address: "<< &aaa << endl;
    cout<<"aap: "<< (int*)*(int*)(&aaa) << endl;

    pFun = (Fun)*(int*)*(int*)(&a);
    pFun();
    pFun = (Fun)*((int*)*(int*)(&a)+1);
    pFun();
    pFun = (Fun)*((int*)*(int*)(&a)+2);
    pFun();

    pFun = (Fun)*(int*)*(int*)(&aa);
    pFun();
    pFun = (Fun)*((int*)*(int*)(&aa)+1);
    pFun();
    pFun = (Fun)*((int*)*(int*)(&aa)+2);
    pFun();
    pFun = (Fun)*((int*)*(int*)(&aa)+3);
    pFun();
    pFun = (Fun)*((int*)*(int*)(&aa)+4);
    pFun();

    pFun = (Fun)*(int*)*(int*)(&aaa);
    pFun();


    cout<<"sizeof A:" << sizeof(A) <<endl;
    cout<<"sizeof AA:" << sizeof(AA) <<endl;
    cout<<"sizeof AAA:" << sizeof(AAA) <<endl;

    cout<<"sizeof a:" << sizeof(a) <<endl;
    cout<<"sizeof aa:" << sizeof(aa) <<endl;
    cout<<"sizeof aaa:" << sizeof(aaa) <<endl;
}

验证：

结论一：虚函数指针存储在类其他成员之前

看这里：

    cout<<"address: "<< &aa << endl;
    cout<<"aap: "<< (int*)*(int*)(&aa) << endl;
    ....
    pFun = (Fun)*(int*)*(int*)(&aa);
    pFun();
    pFun = (Fun)*((int*)*(int*)(&aa)+1);
    pFun();
    pFun = (Fun)*((int*)*(int*)(&aa)+2);
    pFun();
    pFun = (Fun)*((int*)*(int*)(&aa)+3);
    pFun();
    pFun = (Fun)*((int*)*(int*)(&aa)+4);
    pFun();

获取虚函数表地址的方式是：找到对象的首地址，获取该地址内存放的地址。在验证之初假设虚函数指针在类的最前面，代码运行正常，得证。

结论二：基类的虚函数表、子类的虚函数表是分别存放的

ap、aap、aaap分别代表基类、子类、孙子类的虚函数表地址，得证；

结论三：子类虚函数表中存储的内容依次为：继承自基类的虚函数（按声明顺序存放）、子类自己的虚函数（按声明顺序存放）；

将子类中覆盖基类的a()方法注释掉，运行截图如下：

框内为子类虚函数表的存放内容：依次是基类的三个方法按声明顺序存放，子类两个方法按声明顺序存放；

结论四：即使子类没有自己的虚函数，他仍然会创建一个虚函数指针以及虚函数表，虚函数表内容与父类相同，但存放地址不同。

将子类代码修改为，实际就是注释掉所有自己的方法：

class AA :public A {
    //void a(){cout << "AA:a" <<endl;}
    //virtual void aa(){cout << "AA:aa" <<endl;}
    //virtual void bb(){cout << "AA:bb" <<endl;}
};

再次运行结果：

看橙色框内的内容：地址是不相同的，但打印出来的内容是相同的（无覆盖）。

结论五：当有覆盖发生时，子类虚函数表更新，基类不变。

修改子类代码：

class AA :public A {
    void a(){cout << "AA:a" <<endl;}
    virtual void aa(){cout << "AA:aa" <<endl;}
    virtual void bb(){cout << "AA:bb" <<endl;}
};

运行结果：

父类的虚函数表内容没有改变，子类虚函数表原本为基类的a( )方法，替换为了子类的a( )方法。

以上五个结论得到验证。