C++虚函数及虚函数表解析

C++中的虚函数机制

虚函数的定义:
虚函数必须是类的非静态成员函数(且非构造函数),其访问权限是 public(可以定义为 private or proteceted, 但是对于多态来说,没有意义)。在基类的类定义中定义虚函数的一般形式:

virtual 函数返回值类型 虚函数名(形参表)
{ 函数体 }

虚函数的作用是实现动态联编,也就是在程序的运行阶段动态地选择合适的成员函数,在定义了虚函数后,可以在基类的派生类中对虚函数重新定义(形式也是:virtual 函数返回值类型 虚函数名(形参表){ 函数体 }),在派生类中重新定义的函数应与虚函数具有相同的形参个数和形参类型。以实现统一的接口,不同定义过程。如果在派生类中没有对虚函数重新定义,则它继承其基类的虚函数。当程序发现虚函数名前的关键字 virtual 后,会自动将其作为动态联编处理,即在程序运行时动态地选择合适的成员函数。
实现动态联编需要三个条件:

  1. 必须把需要动态联编的行为定义为类的公共属性的虚函数。
  2. 类之间存在子类型关系,一般表现为一个类从另一个类公有派生而来。
  3. 必须先使用基类指针指向子类型的对象,然后直接或者间接使用基类指针调用虚函数。(或者在需要基类引用的地方传入之类对象)

定义虚函数的限制:
(1)非类的成员函数不能定义为虚函数,类的成员函数中静态成员函数和构造函数也不能定义为虚函数,但可以将析构函数定义为虚函数。实际上,优秀的程序员常常把基类的析构函数
定义为虚函数。因为,将基类的析构函数定义为虚函数后,当利用delete删除一个指向派生类定义的对象指针时,系统会调用相应的类的析构函数。而不将析构函数定义为虚函数时,只调用基类的析构函数。
(2)只需要在声明函数的类体中使用关键字“virtual”将函数声明为虚函数,而定义函数时不需要使用关键字“virtual”。
(3)如果声明了某个成员函数为虚函数,则在该类中不能出现和这个成员函数同名并且返回值、参数个数、参数类型都相同的非虚函数。在以该类为基类的派生类中,也不能出现这种非虚的同名同返回值同参数个数同参数类型函数。
为什么虚函数必须是类的成员函数:
虚函数诞生的目的就是为了实现多态,在类外定义虚函数毫无实际用处。
为什么类的静态成员函数不能为虚函数:

如果定义为虚函数,那么它就是动态绑定的,也就是在派生类中可以被覆盖的,这与静态成员函数的定义(:在内存中只有一份拷贝;通过类名或对象引用访问静态成员)本身就是相矛盾的。
为什么构造函数不能为虚函数:
因为如果构造函数为虚函数的话,它将在执行期间被构造,而执行期则需要对象已经建立,构造函数所完成的工作就是为了建立合适的对象,因此在没有构建好的对象上不可能执行多态(虚函数的目的就在于实现多态性)的工作。在继承体系中,构造的顺序就是从基类到派生类, 其目的就在于确保对象能够成功地构建。构造函数同时承担着虚函数表的建立,如果它本身都是虚函数的话,如何确保 vtbl 的构建成功呢?
注意:当基类的构造函数内部有虚函数时,会出现什么情况呢? 结果是在构造函数中,虚函数机制不起作用了,调用虚函数如同调用一般的成员函数一样。当基类的析构函数内部有虚函数时,又如何工作呢?与构造函数相同,只有“局部”的版本被调用。但是,行为相同,原因是不一样的。构造函数只能调用“局部”版本,是因为调用时还没有派生类版本的信息。析构函数则是因为派生类 版本的信息已经不可靠了。我们知道,析构函数的调用顺序与构造函数相反,是从派生类的析构函数到基类的析构函数。当某个类的析构函数被调用时,其派生类的 析构函数已经被调用了,相应的数据也已被丢失,如果再调用虚函数的派生类的版本,就相当于对一些不可靠的数据进行操作,这是非常危险的。因此,在析构函数 中,虚函数机制也是不起作用的。

 

C++ 虚函数表解析

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

前言

C++中 的虚函数的作用主要是实现了多态的机制。关于多态,简而言之就是用父类型别的指针指向其子类的实例,然后通过父类的指针调用实际子类的成员函数。这种技术 可以让父类的指针有“多种形态”,这是一种泛型技术。所谓泛型技术,说白了就是试图使用不变的代码来实现可变的算法。比如:模板技术,RTTI技术,虚函数技术,要么是试图做到在编译时决议,要么试图做到运行时决议。 

关于虚函数的使用方法,我在这里不做过多的阐述。大家可以看看相关的C++的书籍。在这篇文章中,我只想从虚函数的实现机制上面为大家一个清晰的剖析。

当然,相同的文章在网上也出现过一些了,但我总感觉这些文章不是很容易阅读,大段大段的代码,没有图片,没有详细的说明,没有比较,没有举一反三。不利于学习和阅读,所以这是我想写下这篇文章的原因。也希望大家多给我提意见。

言归正传,让我们一起进入虚函数的世界。

虚函数表

C++了解的人都应该知道虚函数(Virtual Function)是通过一张虚函数表(Virtual Table来实现的。简称为V-Table。 在这个表中,主是要一个类的虚函数的地址表,这张表解决了继承、覆盖的问题,保证其容真实反应实际的函数。这样,在有虚函数的类的实例中这个表被分配在了 这个实例的内存中,所以,当我们用父类的指针来操作一个子类的时候,这张虚函数表就显得由为重要了,它就像一个地图一样,指明了实际所应该调用的函数。

这里我们着重看一下这张虚函数表。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; }
};

按照上面的说法,我们可以通过Base的实例来得到虚函数表。 下面是实际例程:

int test1(){
    typedef void (*Fun)();
    Base b;
    Fun pFun=NULL;
    cout<<"虚函数表地址:"<<(int*)&b<<endl;
    cout<<"虚函数表-第一个函数地址:"<<(int*)*(int*)&b<<endl;
    cout<<"虚函数表-第二个函数地址:"<<(int*)*(int*)&b+1<<endl;
    cout<<"虚函数表-第三个函数地址:"<<(int*)*(int*)&b+2<<endl;
    for(int i=0;i<3;i++)
    {
    pFun=(Fun)*((int*)*(int*)&b+i);                                 
    pFun();
    }
    return 0;
}

 实际运行结果如下:(Windows XP+VS2003, Linux 2.6.22 + GCC 4.1.3)

通过这个示例,我们可以看到,我们可以通过强行把&b转成int*,取得虚函数表的地址,然后,再次取址就可以得到第一个虚函数的地址了,也就是Base::f(),这在上面的程序中得到了验证(把int* 强制转成了函数指针)。通过这个示例,我们就可以知道如果要调用Base::g()Base::h(),其代码如下: 

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

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

            (Fun)*((int*)*(int*)(&b)+2); // Base::h()

 

这个时候你应该懂了吧。什么?还是有点晕。也是,这样的代码看着太乱了。没问题,让我画个图解释一下。如下所示:

注意:在上面这个图中,我在虚函数表的最后多加了一个结点,这是虚函数表的结束结点,就像字符串的结束符“/0”一样,其标志了虚函数表的结束。这个结束标志的值在不同的编译器下是不同的。在WinXP+VS2003下,这个值是NULL。而在Ubuntu 7.10 + Linux 2.6.22 + GCC 4.1.3下,这个值是如果1,表示还有下一个虚函数表,如果值是0,表示是最后一个虚函数表。

 

下面,我将分别说明“无覆盖”和“有覆盖”时的虚函数表的样子。没有覆盖父类的虚函数是毫无意义的。我之所以要讲述没有覆盖的情况,主要目的是为了给一个对比。在比较之下,我们可以更加清楚地知道其内部的具体实现。

一般继承(无虚函数覆盖)

下面,再让我们来看看继承时的虚函数表是什么样的。假设有如下所示的一个继承关系: 

请注意,在这个继承关系中,子类没有重载任何父类的函数。那么,在派生类的实例中,其虚函数表如下所示:

 

对于实例:Derive d; 的虚函数表如下:

我们可以看到下面几点:

1)虚函数按照其声明顺序放于表中。

2)父类的虚函数在子类的虚函数前面。

我相信聪明的你一定可以参考前面的那个程序,来编写一段程序来验证。

对上面的程序进行一下改动,得到如下测试代码:

class Base{
    public
        typedef void (Base::*Fun)();
        virtual void f(){
            Fun q=&Base::f;
            cout<<"Base::f -> "<<(int)*(void**)&q<<endl;
        }   
        virtual void g(){
            Fun q=&Base::g;
            cout<<"Base::g -> "<<(int)*(void**)&q<<endl;
        }   
        virtual void h(){
            Fun q=&Base::h;
            cout<<"Base::h -> "<<(int)*(void**)&q<<endl;
        }
};  
class Derive:public Base{
    public:
        typedef void (Derive::*Fun)();
        virtual void f1(){
            Fun q=&Derive::f1;
            cout<<"Derive::f1 -> "<<(int)*(void**)&q<<endl;
        }
        virtual void g1(){
            Fun q=&Derive::g1;
            cout<<"Derive::g1 -> "<<(int)*(void**)&q<<endl;
        }
        virtual void h1(){
            Fun q=&Derive::h1;
            cout<<"Derive::h1 -> "<<(int)*(void**)&q<<endl;
        }
};      
 int test2(){
     typedef void (*Fun)();
     Base b;
     Fun pFun=NULL;
     int *add;
     cout<<"虚函数表地址:"<<(int*)&b<<endl;
     add=(int*)*(int*)&b;
     cout<<"虚函数表-第1个函数地址:"<<add<<" -> "<<(int*)(*add)<<endl;
     cout<<"虚函数表-第2个函数地址:"<<add+1<<" -> "<<(int*)*(add+1)<<endl;
     cout<<"虚函数表-第3个函数地址:"<<add+2<<" -> "<<(int*)*(add+2)<<endl;
     for(int i=0;i<3;i++)
     {
     pFun=(Fun)*((int*)*(int*)&b+i);
     pFun();
     }
     cout<<"=================================="<<endl;
     Derive d;
     cout<<"虚函数表地址:"<<(int*)&d<<endl;
     add=(int*)*(int*)&d;
     cout<<"虚函数表-第1个函数地址:"<<add<<" -> "<<(int*)(*add)<<endl;
     cout<<"虚函数表-第2个函数地址:"<<add+1<<" -> "<<(int*)*(add+1)<<endl;
     cout<<"虚函数表-第3个函数地址:"<<add+2<<" -> "<<(int*)*(add+2)<<endl;
     cout<<"虚函数表-第4个函数地址:"<<add+3<<" -> "<<(int*)*(add+3)<<endl;
     cout<<"虚函数表-第5个函数地址:"<<add+4<<" -> "<<(int*)*(add+4)<<endl;
     cout<<"虚函数表-第6个函数地址:"<<add+5<<" -> "<<(int*)*(add+5)<<endl;     
     for(int i=0;i<6;i++)
     {
     pFun=(Fun)*((int*)*(int*)&d+i);
     pFun();
     }
     return 0;
 }

 测试结果如下:

从上图可以看到,派生类的前三个函数就是从基类中继承来的,函数的地址是不一样的,但是所指向的内存中函数的地址是一致的。

一般继承(有虚函数覆盖) 

覆盖父类的虚函数是很显然的事情,不然,虚函数就变得毫无意义。下面,我们来看一下,如果子类中有虚函数重载了父类的虚函数,会是一个什么样子?假设,我们有下面这样的一个继承关系。

为了让大家看到被继承过后的效果,在这个类的设计中,我只覆盖了父类的一个函数:f()。那么,对于派生类的实例,其虚函数表会是下面的一个样子:
 我们从表中可以看到下面几点,

1)覆盖的f()函数被放到了虚表中原来父类虚函数的位置。

2)没有被覆盖的函数依旧。

对应的测试代码为:

View Code
class Derive2:public Base{
    public
        typedef void (Derive::*Fun)();
        virtual void f(){
            Fun q=&Derive::f;
            cout<<"Derive::f -> "<<(int)*(void**)&q<<endl;
        }
        virtual void g1(){
            Fun q=&Derive::g1;
            cout<<"Derive::g1 -> "<<(int)*(void**)&q<<endl;
        }
        virtual void h1(){
            Fun q=&Derive::h1;
            cout<<"Derive::h1 -> "<<(int)*(void**)&q<<endl;
        }
};      
int test3(){
    typedef void (*Fun)();
    Base b;
    Fun pFun=NULL;
    int *add;
    cout<<"虚函数表地址:"<<(int*)&b<<endl;
    add=(int*)*(int*)&b;                                                        
    cout<<"虚函数表-第1个函数地址:"<<add<<" -> "<<(int*)(*add)<<endl;
    cout<<"虚函数表-第2个函数地址:"<<add+1<<" -> "<<(int*)*(add+1)<<endl;
    cout<<"虚函数表-第3个函数地址:"<<add+2<<" -> "<<(int*)*(add+2)<<endl;
    for(int i=0;i<3;i++)
    {
    pFun=(Fun)*((int*)*(int*)&b+i);
    pFun();
    }
    cout<<"=================================="<<endl;
    Derive2 d;
    cout<<"虚函数表地址:"<<(int*)&d<<endl;
    add=(int*)*(int*)&d;
    cout<<"虚函数表-第1个函数地址:"<<add<<" -> "<<(int*)(*add)<<endl;
    cout<<"虚函数表-第2个函数地址:"<<add+1<<" -> "<<(int*)*(add+1)<<endl;
    cout<<"虚函数表-第3个函数地址:"<<add+2<<" -> "<<(int*)*(add+2)<<endl;
    cout<<"虚函数表-第4个函数地址:"<<add+3<<" -> "<<(int*)*(add+3)<<endl;
    cout<<"虚函数表-第5个函数地址:"<<add+4<<" -> "<<(int*)*(add+4)<<endl;
    cout<<"虚函数表-第6个函数地址:"<<add+5<<" -> "<<(int*)*(add+5)<<endl;
    for(int i=0;i<5;i++)
    {
    pFun=(Fun)*((int*)*(int*)&d+i);
    pFun();
    }
    return 0;
}   

对应的测试结果:

 

从上图我们可以看到在派生类中的函数f已经覆盖了基类中对应的函数f,并且派生类的虚表的函数地址换成了派生类函数的地址。因为不存在第6个函数,所以最后的地址为0

这样,我们就可以看到对于下面这样的程序,

            Base *b = new Derive();

            b->f();

b所指的内存中的虚函数表的f()的位置已经被Derive::f()函数地址所取代,于是在实际调用发生时,是Derive::f()被调用了。这就实现了多态。

多重继承(无虚函数覆盖)

下面,再让我们来看看多重继承中的情况,假设有下面这样一个类的继承关系。注意:子类并没有覆盖父类的函数。

对于子类实例中的虚函数表,是下面这个样子:
 

我们可以看到:

1) 每个父类都有自己的虚表。

2) 子类的成员函数被放到了第一个父类的表中。(所谓的第一个父类是按照声明顺序来判断的)

这样做就是为了解决不同的父类类型的指针指向同一个子类实例,而能够调用到实际的函数。

测试代码如下:

View Code
#include <iostream>
using namespace std;
class Base1{
    public:
        typedef void (Base1::*Fun)();
        virtual void f(){
            Fun q=&Base1::f;
            cout<<"Base1::f -> "<<(int)*(void**)&q<<endl;
        }
        virtual void g(){
            Fun q=&Base1::g;
            cout<<"Base1::g -> "<<(int)*(void**)&q<<endl;
        }
        virtual void h(){
            Fun q=&Base1::h;
            cout<<"Base1::h -> "<<(int)*(void**)&q<<endl;
        }
};
class Base2{
    public:
        typedef void (Base2::*Fun)();
        virtual void f(){
            Fun q=&Base2::f;
            cout<<"Base2::f -> "<<(int)*(void**)&q<<endl;
        }
        virtual void g(){
            Fun q=&Base2::g;
            cout<<"Base2::g -> "<<(int)*(void**)&q<<endl;
        }
        virtual void h(){
            Fun q=&Base2::h;
            cout<<"Base2::h -> "<<(int)*(void**)&q<<endl;
        }
};
class Base3{
    public:
        typedef void (Base3::*Fun)();
        virtual void f(){
            Fun q=&Base3::f;
            cout<<"Base3::f -> "<<(int)*(void**)&q<<endl;
        }
        virtual void g(){
            Fun q=&Base3::g;
            cout<<"Base3::g -> "<<(int)*(void**)&q<<endl;
        }
        virtual void h(){
            Fun q=&Base3::h;
            cout<<"Base3::h -> "<<(int)*(void**)&q<<endl;
        }
};
class Derive:public Base1,public Base2,public Base3{
    public:
        typedef void (Derive::*Fun)();
        virtual void f1(){
            Fun q=&Derive::f1;
            cout<<"Derive::f1 -> "<<(int)*(void**)&q<<endl;
        }
        virtual void g1(){
            Fun q=&Derive::g1;
            cout<<"Derive::g1 -> "<<(int)*(void**)&q<<endl;
        }
};
int test2(){
    typedef void (*Fun)();
    Fun pFun=NULL;
    int *add;
    Base1 b1;
    add=(int*)*(int*)&b1;
    cout<<"Base1-虚函数表地址:"<<(int*)&b1<<endl;
    cout<<"虚函数表-第1个函数地址:"<<add<<" -> "<<(int*)(*add)<<endl;
    cout<<"虚函数表-第2个函数地址:"<<add+1<<" -> "<<(int*)*(add+1)<<endl;
    cout<<"虚函数表-第3个函数地址:"<<add+2<<" -> "<<(int*)*(add+2)<<endl;
    for(int i=0;i<3;i++)
    {
    pFun=(Fun)*((int*)*(int*)&b1+i);
    pFun();
    }
    Base2 b2;
    add=(int*)*(int*)&b2;
    cout<<"Base2-虚函数表地址:"<<(int*)&b2<<endl;
    cout<<"虚函数表-第1个函数地址:"<<add<<" -> "<<(int*)(*add)<<endl;
    cout<<"虚函数表-第2个函数地址:"<<add+1<<" -> "<<(int*)*(add+1)<<endl;
    cout<<"虚函数表-第3个函数地址:"<<add+2<<" -> "<<(int*)*(add+2)<<endl;
    for(int i=0;i<3;i++)
    {
    pFun=(Fun)*(add+i);
    pFun();
    }
    Base3 b3;
    add=(int*)*(int*)&b3;
    cout<<"Base3-虚函数表地址:"<<(int*)&b3<<endl;
    cout<<"虚函数表-第1个函数地址:"<<add<<" -> "<<(int*)(*add)<<endl;
    cout<<"虚函数表-第2个函数地址:"<<add+1<<" -> "<<(int*)*(add+1)<<endl;
    cout<<"虚函数表-第3个函数地址:"<<add+2<<" -> "<<(int*)*(add+2)<<endl;
    for(int i=0;i<3;i++)
    {
    pFun=(Fun)*(add+i);
    pFun();
    }
    cout<<"=================================="<<endl;
    Derive d;
    add=(int*)*(int*)&d;
    cout<<"Derive-虚函数表1地址:"<<(int*)&d<<endl;
    cout<<"虚函数表1-第1个函数地址:"<<add<<" -> "<<(int*)(*add)<<endl;
    cout<<"虚函数表1-第2个函数地址:"<<add+1<<" -> "<<(int*)*(add+1)<<endl;
    cout<<"虚函数表1-第3个函数地址:"<<add+2<<" -> "<<(int*)*(add+2)<<endl;
    cout<<"虚函数表1-第4个函数地址:"<<add+3<<" -> "<<(int*)*(add+3)<<endl;
    cout<<"虚函数表1-第5个函数地址:"<<add+4<<" -> "<<(int*)*(add+4)<<endl;
    for(int i=0;i<5;i++)
    {
    pFun=(Fun)*(add+i);
    pFun();
    }

    add=(int*)*((int*)&d+1);
    cout<<"Derive-虚函数表2地址:"<<(int*)&d+1<<endl;
    cout<<"虚函数表2-第1个函数地址:"<<add<<" -> "<<(int*)(*add)<<endl;
    cout<<"虚函数表2-第2个函数地址:"<<add+1<<" -> "<<(int*)*(add+1)<<endl;
    cout<<"虚函数表2-第3个函数地址:"<<add+2<<" -> "<<(int*)*(add+2)<<endl;
    cout<<"虚函数表2-第4个函数地址:"<<add+3<<" -> "<<(int*)*(add+3)<<endl;
    cout<<"虚函数表2-第5个函数地址:"<<add+4<<" -> "<<(int*)*(add+4)<<endl;
    for(int i=0;i<3;i++)
    {
    pFun=(Fun)*(add+i);
    pFun();
    }

    add=(int*)*((int*)&d+2);
    cout<<"Derive-虚函数表3地址:"<<(int*)&d+2<<endl;
    cout<<"虚函数表3-第1个函数地址:"<<add<<" -> "<<(int*)(*add)<<endl;
    cout<<"虚函数表3-第2个函数地址:"<<add+1<<" -> "<<(int*)*(add+1)<<endl;
    cout<<"虚函数表3-第3个函数地址:"<<add+2<<" -> "<<(int*)*(add+2)<<endl;
    cout<<"虚函数表3-第4个函数地址:"<<add+3<<" -> "<<(int*)*(add+3)<<endl;
    cout<<"虚函数表3-第5个函数地址:"<<add+4<<" -> "<<(int*)*(add+4)<<endl;
    for(int i=0;i<3;i++)
    {
    pFun=(Fun)*(add+i);
    pFun();
    }
    return 0;
}
int main(){
    test2();
}

 

 从上图可以看到派生类中确实有3个虚表,分别保存来自3个基类的虚函数。派生类的虚表2和虚表3只有三个函数,所以图中对于虚表2和虚表3的第4个和第5个函数指向的地址都是无效的。

 多重继承(有虚函数覆盖)

下面我们再来看看,如果发生虚函数覆盖的情况。

下图中,我们在子类中覆盖了父类的f()函数。

 

下面是对于子类实例中的虚函数表的图:

测试代码如下:

View Code
class Derive2:public Base1,public Base2,public Base3{
    public:
        typedef void (Derive2::*Fun)();
        virtual void f(){
            Fun q=&Derive2::f;
            cout<<"Derive2::f -> "<<(int)*(void**)&q<<endl;
        }
        virtual void g1(){
            Fun q=&Derive2::g1;
            cout<<"Derive2::g1 -> "<<(int)*(void**)&q<<endl;
        }
};
int test3(){
    typedef void (*Fun)();
    Fun pFun=NULL;
    int *add;
    Base1 b1;
    add=(int*)*(int*)&b1;
    cout<<"Base1-虚函数表地址:"<<(int*)&b1<<endl;
    cout<<"虚函数表-第1个函数地址:"<<add<<" -> "<<(int*)(*add)<<endl;
    cout<<"虚函数表-第2个函数地址:"<<add+1<<" -> "<<(int*)*(add+1)<<endl;
    cout<<"虚函数表-第3个函数地址:"<<add+2<<" -> "<<(int*)*(add+2)<<endl;
    for(int i=0;i<3;i++)
    {
    pFun=(Fun)*((int*)*(int*)&b1+i);
    pFun();
    }
    Base2 b2;
    add=(int*)*(int*)&b2;
    cout<<"Base2-虚函数表地址:"<<(int*)&b2<<endl;
    cout<<"虚函数表-第1个函数地址:"<<add<<" -> "<<(int*)(*add)<<endl;
    cout<<"虚函数表-第2个函数地址:"<<add+1<<" -> "<<(int*)*(add+1)<<endl;
    cout<<"虚函数表-第3个函数地址:"<<add+2<<" -> "<<(int*)*(add+2)<<endl;
    for(int i=0;i<3;i++)
    {
    pFun=(Fun)*(add+i);
    pFun();
    }
    Base3 b3;
    add=(int*)*(int*)&b3;
    cout<<"Base3-虚函数表地址:"<<(int*)&b3<<endl;
    cout<<"虚函数表-第1个函数地址:"<<add<<" -> "<<(int*)(*add)<<endl;
    cout<<"虚函数表-第2个函数地址:"<<add+1<<" -> "<<(int*)*(add+1)<<endl;
    cout<<"虚函数表-第3个函数地址:"<<add+2<<" -> "<<(int*)*(add+2)<<endl;
    for(int i=0;i<3;i++)
    {
    pFun=(Fun)*(add+i);
    pFun();
    }
    cout<<"=================================="<<endl;
    Derive2 d;
    add=(int*)*(int*)&d;
    cout<<"Derive2-虚函数表1地址:"<<(int*)&d<<endl;
    cout<<"虚函数表1-第1个函数地址:"<<add<<" -> "<<(int*)(*add)<<endl;
    cout<<"虚函数表1-第2个函数地址:"<<add+1<<" -> "<<(int*)*(add+1)<<endl;
    cout<<"虚函数表1-第3个函数地址:"<<add+2<<" -> "<<(int*)*(add+2)<<endl;
    cout<<"虚函数表1-第4个函数地址:"<<add+3<<" -> "<<(int*)*(add+3)<<endl;
    cout<<"虚函数表1-第5个函数地址:"<<add+4<<" -> "<<(int*)*(add+4)<<endl;
    for(int i=0;i<4;i++)
    {
    pFun=(Fun)*(add+i);
    pFun();
    }

    add=(int*)*((int*)&d+1);
    cout<<"Derive2-虚函数表2地址:"<<(int*)&d+1<<endl;
    cout<<"虚函数表2-第1个函数地址:"<<add<<" -> "<<(int*)(*add)<<endl;
    cout<<"虚函数表2-第2个函数地址:"<<add+1<<" -> "<<(int*)*(add+1)<<endl;
    cout<<"虚函数表2-第3个函数地址:"<<add+2<<" -> "<<(int*)*(add+2)<<endl;
    cout<<"虚函数表2-第4个函数地址:"<<add+3<<" -> "<<(int*)*(add+3)<<endl;
    cout<<"虚函数表2-第5个函数地址:"<<add+4<<" -> "<<(int*)*(add+4)<<endl;
    for(int i=0;i<3;i++)
    {
    pFun=(Fun)*(add+i);
    pFun();
    }

    add=(int*)*((int*)&d+2);
    cout<<"Derive2-虚函数表3地址:"<<(int*)&d+2<<endl;
    cout<<"虚函数表3-第1个函数地址:"<<add<<" -> "<<(int*)(*add)<<endl;
    cout<<"虚函数表3-第2个函数地址:"<<add+1<<" -> "<<(int*)*(add+1)<<endl;
    cout<<"虚函数表3-第3个函数地址:"<<add+2<<" -> "<<(int*)*(add+2)<<endl;
    cout<<"虚函数表3-第4个函数地址:"<<add+3<<" -> "<<(int*)*(add+3)<<endl;
    cout<<"虚函数表3-第5个函数地址:"<<add+4<<" -> "<<(int*)*(add+4)<<endl;
    for(int i=0;i<3;i++)
    {
    pFun=(Fun)*(add+i);
    pFun();
    }
    return 0;
}