C++虚函数表

大家知道虚函数是通过一张虚函数表来实现的。在这个表中，主要是一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，其内容真是反应实际的函数。这样，在有虚函数的类的实例中，这个表分配在了这个实例的内存中，所以，当用父类的指针来操作一个子类的时候，这张虚函数表就显得尤为重要了。它就像一个地图一样，指明了实际所应该调用的函数。

C++的标准规则中说到，编译器必须保证虚函数表的指针存在于对象实例中最前面的位置（这样是为了保证正确取到虚函数的偏移量）。这意味着通过对象实例的地址得到这张虚函数表，然后可以遍历其中的函数指针，并调用相应的函数。

#include <iostream>

using namespace std;

class Base

{

public:

    virtual void fun1(){cout<<"Base::fun1\n";}

    virtual void fun2(){cout<<"Base::fun2\n";}

    virtual void fun3(){cout<<"Base::fun3\n";}

private:

    int num1;

    int num2;

};

typedef void (*Fun)(void);

int main()

{

    Base b;

    Fun pFun;

    //通过指针分别调用了对象b的3个虚函数。

    pFun = (Fun)* ( (int*)*(int*)(&b)+ );

    pFun();

    pFun = (Fun)* ( (int*)*(int*)(&b)+ );

    pFun();

    pFun = (Fun)* ( (int*)*(int*)(&b)+ );

    pFun();

    return ;

}

/*

程序执行结果如下：

Base::fun1

Base::fun2

Base::fun3

Press <RETURN> to close this window...

*/

程序中的Base对象b内存结构如下：

一个类会有多少张虚函数表呢？

对于一个单继承的类，如果它有虚函数，则只有一张虚函数表。对于多重继承的类，它可能有多张虚函数的表。

#include <iostream>

using namespace std;

class Base1

{

public:

    Base1(int num):num_1(num){}

    virtual void fun1(){cout<<"Base1::fun1 "<<num_1<<endl;}

    virtual void fun2(){cout<<"Base1::fun2 "<<num_1<<endl;}

    virtual void fun3(){cout<<"Base1::fun3 "<<num_1<<endl;}

private:

    int num_1;

};

class Base2

{

public:

    Base2(int num):num_2(num){}

    virtual void fun1(){cout<<"Base2::fun1 "<<num_2<<endl;}

    virtual void fun2(){cout<<"Base2::fun2 "<<num_2<<endl;}

    virtual void fun3(){cout<<"Base2::fun3 "<<num_2<<endl;}

private:

    int num_2;

};

class Base3

{

public:

    Base3(int num):num_3(num){}

    virtual void fun1(){cout<<"Base3::fun1 "<<num_3<<endl;}

    virtual void fun2(){cout<<"Base3::fun2 "<<num_3<<endl;}

    virtual void fun3(){cout<<"Base3::fun3 "<<num_3<<endl;}

private:

    int num_3;

};

class Derived1:public Base1

{

public:

    Derived1(int num):Base1(num){}

    virtual void fDer1_1(){cout<<"Derived1::fDer1_1\n";}//无覆盖

    virtual void fDer1_2(){cout<<"Derived1::fDer1_2\n";}

};

class Derived2:public Base1

{

public:

    Derived2(int num):Base1(num){}

    virtual void fun2(){cout<<"Derived2::fun2 "<<endl;}//只覆盖了Base1：：fun2

    virtual void fDer2_1(){cout<<"Derived2::fDer2_1\n";}

    virtual void fDer2_2(){cout<<"Derived2::fDer2_2\n";}

};

class Derived3:public Base1,public Base2,public Base3//多重继承，无覆盖

{

public:

    Derived3(int num_1,int num_2,int num_3):Base1(num_1),Base2(num_2),Base3(num_3){}

    virtual void fDer3_1(){cout<<"Derived3::fDer3_1\n";}

    virtual void fDer3_2(){cout<<"Derived3::fDer3_2\n";}

};

class Derived4:public Base1,public Base2,public Base3//多重继承，有覆盖

{

public:

    Derived4(int num_1,int num_2,int num_3):Base1(num_1),Base2(num_2),Base3(num_3){}

    virtual void fun1(){cout<<"Derived4::fun1\n";}//覆盖了所有基类的fun1函数

    virtual void fDer4_1(){cout<<"Derived4::fDer4_1\n";}

};

int main()

{

    Base1 *pBase1 = NULL;

    Base2 *pBase2 = NULL;

    Base3 *pBase3 = NULL;

    cout<<"-----  Generally inherited from Base1, no cover------\n";

    Derived1 d1();

    pBase1 = &d1;

    pBase1->fun1();

    cout<<"----- Generally inherited from Base1, covering fun2---\n";

    Derived2 d2();

    pBase1 = &d2;

    pBase1->fun2();

    cout<<"-----  Multiple inheritance, no cover-----------------\n";

    Derived3 d3(,,);

    pBase1 = &d3;

    pBase2 = &d3;

    pBase3 = &d3;

    pBase1->fun1();

    pBase2->fun1();

    pBase3->fun1();

    cout<<"-----  Multiple inheritance, covering fun1-------------\n";

    Derived4 d4(,,);

    pBase1 = &d4;

    pBase2 = &d4;

    pBase3 = &d4;

    pBase1->fun1();

    pBase2->fun1();

    pBase3->fun1();

    return ;

}

/*

 * 程序运行结果如下：

-----  Generally inherited from Base1, no cover------

Base1::fun1 1

----- Generally inherited from Base1, covering fun2---

Derived2::fun2

-----  Multiple inheritance, no cover-----------------

Base1::fun1 1

Base2::fun1 2

Base3::fun1 3

-----  Multiple inheritance, covering fun1-------------

Derived4::fun1

Derived4::fun1

Derived4::fun1

Press <RETURN> to close this window...

*/

一般继承（无虚函数覆盖）

Derived1类继承自Base1类，没有任何覆盖基类的函数，因此Dervied1的两个虚拟函数被依次添加到了虚函数表的尾部。Derived1的虚函数表如下图：

一般继承（有虚函数的覆盖）

Derived2继承自Base1类，并对基类中的fun2()进行了覆盖。所以虚函数表中的Derived2::fun2代替了Base::fun2，用时派生类中新的虚函数添加到虚函数的表尾。Derived2的虚函数表如下图：

多重继承（无虚函数覆盖）

Derived3继承自Base1，Base2，Base3，其虚函数表如下：

Derived3的每个父类都有自己的虚表，所以Derived3也就有了3个虚表。这里父类虚表的顺序与声明继承父类的顺序一致。这样做就是为了解决不同的父类类型的指针指向同一个子类实例，而能够调用到实际的函数。例如：

Base2 *pBase2 = new Derived3();

pBase->fun2();

把Base2类型的指针指向Derived3实例,那么调用将是对应Base2虚表里的那些函数.

多重继承（有虚函数覆盖）

Derived4类继承自Base1，Base2，Base3并对3个基类的fun1函数进行了覆盖。其虚函数表如下：

可以看见基类中的fun1都被替换成了Derived4::fun1，这样，我们就可以把任意一个静态类型的父类指向子类，并调用子类的f()了。

Base1 *pBase1 = new Derived4();

pBase1->fun1();

巴特西

C++虚函数表

最新文章

热门文章