精华内容
下载资源
问答
  • c++ 虚表

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


    二 虚函数表

     

             对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的实例来得到虚函数表。 下面是实际例程:


      Base b;
      b. f();
      Fun pFun = NULL;
      cout << "虚函数表的地址: " <<     ( int *)& b << endl ;
      cout << "虚函数y表的第一个函数y的地址: " << (int *)*(int *)(&b )<<endl ;
          

    // Invoke the first virtual function
    pFun = (Fun )*((int *)*(int *)(&b ));
    pFun();


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

     

    虚函数表地址:0012FED4

    虚函数表  第一个函数地址:0044F148

    Base::f

     

     

    通过这个示例,我们可以看到,我们可以通过强行把&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,表示是最后一个虚函数表。

     

     

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

     

    2.1 一般继承---无虚函数覆盖

     

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

     


     

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

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

     

    我们可以看到下面几点:

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

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

     

    编写一段程序来验证

     

     #include <iostream>

    using namespace std ;

    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 :Base
    {
    public:
           virtual void f1() { cout<< "Derive::f1"<<endl ;}
           virtual void g1() { cout<< "Derive::g1"<<endl ;}
           virtual void h1() { cout<< "Derive::h1"<<endl ;}
    };
    typedef void (*Fun )(void );
    int main()
    {  
           Base b;
           b. f();
           Fun pFun = NULL;
           cout << "虚函数表的地址: " <<     (int *)& b << endl;
           cout << "虚函数y表的第一个函数y的地址: " << (int*)*(int *)(&b )<<endl ;
          

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

           Derive d;
           pFun = ( Fun)*(( int*)*( int *)(& d)+0);
           pFun();
           pFun = ( Fun)*(( int*)*( int *)(& d)+1);
           pFun();     
           pFun = ( Fun)*(( int*)*( int *)(& d)+2);
           pFun();
           pFun = ( Fun)*(( int*)*( int *)(& d)+3);
           pFun();
           pFun = ( Fun)*(( int*)*( int *)(& d)+4);
           pFun();     
           pFun = ( Fun)*(( int*)*( int *)(& d)+5);
           pFun();
      }

     

    2.2  一般继承---有虚函数覆盖

     

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

     

     

     

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

     


     

    我们从表中可以看到下面几点,

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

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

     

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

     

                Base *b = new Derive();
                b->f();

     

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

     

     #include <iostream>

    using namespace std ;

    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 :Base
    {
    public:
           virtual void f() { cout<< "Derive::f1"<<endl ;}
           virtual void g1() { cout<< "Derive::g1"<<endl ;}
           virtual void h1() { cout<< "Derive::h1"<<endl ;}
    };
    typedef void (*Fun )(void );
    int main()
    {  
          Base b;
           b. f();
           Fun pFun = NULL;
           cout << "虚函数表的地址: " <<     ( int *)& b << endl ;
           cout << "虚函数y表的第一个函数y的地址: " << (int *)*(int *)(&b )<<endl ;
          
          

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

           Derive d;
           pFun = ( Fun)*(( int*)*( int *)(& d)+0);
           pFun();
           pFun = ( Fun)*(( int*)*( int *)(& d)+1);
           pFun();     
           pFun = ( Fun)*(( int*)*( int *)(& d)+2);
           pFun();
           pFun = ( Fun)*(( int*)*( int *)(& d)+3);
           pFun();
           pFun = ( Fun)*(( int*)*( int *)(& d)+4);
           pFun();     
           /*pFun = (Fun)*((int*)*(int *)(&d)+5);
          pFun();*/

     }

    2.3 多重继承---无虚函数覆盖

     

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

     


     

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


     

    我们可以看到:

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

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

     

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

     

     

    2.4 多重继承---有虚函数覆盖

     

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

     

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

     

     

     

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

     


     

    我们可以看见,三个父类虚函数表中的f()的位置被替换成了子类的函数指针。这样,我们就可以任一静态类型的父类来指向子类,并调用子类的f()了。如:

     

                Derive d;

                Base1 *b1 = &d;

                Base2 *b2 = &d;

                Base3 *b3 = &d;

                b1->f(); //Derive::f()

                b2->f(); //Derive::f()

                b3->f(); //Derive::f()

     

                b1->g(); //Base1::g()

                b2->g(); //Base2::g()

                b3->g(); //Base3::g()

     

     

    三 安全性

     

    每次写C++的文章,总免不了要批判一下C++。这篇文章也不例外。通过上面的讲述,相信我们对虚函数表有一个比较细致的了解了。水可载舟,亦可覆舟。下面,让我们来看看我们可以用虚函数表来干点什么坏事吧。

     

    3.1 通过父类型的指针访问子类自己的虚函数

    我们知道,子类没有重载父类的虚函数是一件毫无意义的事情。因为多态也是要基于函数重载的。虽然在上面的图中我们可以看到Base1的虚表中有Derive的虚函数,但我们根本不可能使用下面的语句来调用子类的自有虚函数:

     

              Base1 *b1 = new Derive();

              b1->f1();  //编译出错

     

    任何妄图使用父类指针想调用子类中的未覆盖父类的成员函数的行为都会被编译器视为非法,所以,这样的程序根本无法编译通过。但在运行时,我们可以通过指针的方式访问虚函数表来达到违反C++语义的行为。(关于这方面的尝试,通过阅读后面附录的代码,相信你可以做到这一点)

     

     

    3.2 访问non-public的虚函数

    另外,如果父类的虚函数是private或是protected的,但这些非public的虚函数同样会存在于虚函数表中,所以,我们同样可以使用访问虚函数表的方式来访问这些non-public的虚函数,这是很容易做到的。

     

    如:

     

    #include <iostream>
    using namespace std ;

    class Base
    {
    private:
           virtual void f() { cout<< "Base::f"<<endl ;}
    };
    class Derive :Base
    {
    public:
    };
    typedef void (*Fun )(void );
    int main()
    {  
           Fun pFun = NULL;
           Derive d;
           pFun = ( Fun)*(( int*)*( int *)(& d)+0);
           pFun();
    }
      

     

    四 结束语

            C++这门语言是一门Magic的语言,对于程序员来说,我们似乎永远摸不清楚这门语言背着我们在干了什么。需要熟悉这门语言,我们就必需要了解C++里面的那些东西,需要去了解C++中那些危险的东西。不然,这是一种搬起石头砸自己脚的编程语言。


     

    附录一:VC中查看虚函数表

     

    我们可以在VCIDE环境中的Debug状态下展开类的实例就可以看到虚函数表了(并不是很完整的)


    附录 二:例程

    下面是一个关于多重继承的虚函数表访问的例程:

     

    #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 ; }
    };
     
    class Base2
    {
    public:
        virtual void f() { cout << "Base2::f" << endl ; }
        virtual void g() { cout << "Base2::g" << endl ; }
        virtual void h() { cout << "Base2::h" << 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 ; }
    };
     
     
    class Derive : public Base1 , public Base2 , public Base3 \
    {
    public:
         virtual void f() { cout << "Derive::f" << endl ; }
         virtual void g1() { cout << "Derive::g1" << endl ; }
    };
     
     
    typedef void(*Fun)(void );
     
    int main()
    {
           Fun pFun = NULL;

           Derive d;
           int** pVtab = ( int**)& d;

           //Base1's vtable
           //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+0);
           pFun = ( Fun) pVtab[0][0];
           pFun();

           //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+1);
           pFun = ( Fun) pVtab[0][1];
           pFun();

           //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+2);
           pFun = ( Fun) pVtab[0][2];
           pFun();

           //Derive's vtable
           //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+3);
           pFun = ( Fun) pVtab[0][3];
           pFun();

           //The tail of the vtable
           pFun = ( Fun) pVtab[0][4];
           cout<< pFun<< endl;


           //Base2's vtable
           //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+0);
           pFun = ( Fun) pVtab[1][0];
           pFun();

           //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+1);
           pFun = ( Fun) pVtab[1][1];
           pFun();

           pFun = ( Fun) pVtab[1][2];
           pFun();

           //The tail of the vtable
           pFun = ( Fun) pVtab[1][3];
           cout<< pFun<< endl;



           //Base3's vtable
           //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+0);
           pFun = ( Fun) pVtab[2][0];
           pFun();

           //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+1);
           pFun = ( Fun) pVtab[2][1];
           pFun();

           pFun = ( Fun) pVtab[2][2];
           pFun();

           //The tail of the vtable
           pFun = ( Fun) pVtab[2][3];
           cout<< pFun<< endl;

           return 0;
    }



    展开全文
  • C++虚表

    2011-03-10 23:11:00
    C++虚表 收藏

    (1)

    单一继承,无复盖

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

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

    (2)

    单一继承,又复盖

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

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

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

    Base *b = new Derive();

    b->f();

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

    (3)

    多继承,无复盖

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

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

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

    (4)

    多继承,有复盖

    三个父类虚函数表中的f()的位置被替换成了子类的函数指针。这样,我们就可以任一静态类型的父类来指向子类,并调用子类的f()了。

    (5)

    如果父类的虚函数是private或是protected的,但这些非public的虚函数同样会存在于虚函数表中,所以,我们同样可以使用访问虚函数表的方式来访问这些non-public的虚函数,这是很容易做到的。

     C++虚表探究

    转自:http://blog.csdn.net/vlient/archive/2007/06/10/1647283.aspx

    1. 对相同的同一个class 创建多个object,可以发现 vfptr是指向同一个地址,
       可见一个class 维护一个虚表,与创建对象没有关系

    2. 如果一个基类(没有通过继承创建)含有virtual 函数,则这个这个类会
     额外产生一个虚表,其大小是其成员变量,加上一个函数指针的大小。

    3.  虚表的作用用来实现多态, 其最终的原理是基类可以透明的通过vfptr[index]
     来访问成员函数,这就意味着同一个继承里面的class群,其vfptr每个index
     对应的函数是相同的。

    4.  vfptr的开始的地址用来存放函数指针,后面部分用来存放RTTI信息

    5. 派生类的构造过程:
     1.构造基类,此时this 指针指向的vfptr是基类的vfptr
     2.构造派生类,vfptr的地址转移到派生类的vfptr
     这意味着,在构造函数期间,无法实现本Class体系的多态的行为

    6. 析构的过程和构造一样,会存在vfptr转换的情况

    7. 基类的析构函数如果不是virtual 的会导致基类无法析构
     此外还有更严重的问题:
     如果基类没有虚函数,其则不会产vfptr,此时如果派生有虚函数,
     则派生类会产生vfptr,这样会导致赋值异常.

     Derive* pDerive = new Derive();
     Base *pTestBase  = pDerive;
     
     例如本例中,最终pTestBase 和 pDerive是不等的
     pDerive = 0x003A4F58
     pTestBase = 0x003A4F5C
     
     其内存镜像为
     0x003A4F58  40 67 41 00 
     0x003A4F5C  01 00 00 00 
     0x003A4F60  02 00 00 00 
     0x003A4F64  03 00 00 00 
     
     pDerive 的tihs 指针指向虚表
     而pTestBase没有虚表,会指向第一个元素


    #include <cstdio>
    #include <iostream>

    #define TRACE() printf("%s/r/n",__FUNCTION__);

    class Base
    {
    public:
     Base()
     {
      TRACE();
      m_1 = 1;
      m_2 = 2;
      m_3 = 3;
     }

     /*virtual*/ ~Base()
     {
      TRACE();
     }

     //virtual void Fun1()
     //{
     // TRACE();
     //}
     //virtual void Fun2()
     //{
     // TRACE();
     //}
     //virtual void Fun3()
     //{
     // TRACE();
     //}

    private:
     int m_1;
     int m_2;
     int m_3;
    };

    class Derive :public Base
    {
    public:

     Derive()
     {
      TRACE();
     };
     /*virtual*/ ~Derive()
     {
      TRACE();
     };

     void virtual Testfun()
     {

     }
    };

    int main()
    {
     //Base*  pDerive = new Derive();
     Derive* pDerive = new Derive();
     Base *pTestBase  = pDerive;

     printf("This : 0x%08x  vptr :0x%08x/r/n",pDerive,((int *)pDerive)[0]);
     printf("This : 0x%08x  vptr :0x%08x/r/n",pTestBase,((int *)pTestBase)[0]);
     
     delete pTestBase;
    }

    C++虚表解释

    转自:http://hi.baidu.com/exquisite2007/blog/item/afa95e9509eabc41d0135e2a.html

    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的实例来得到虚函数表。 下面是实际例程:

    typedef void(*Fun)(void);

    Base b;

    Fun pFun = NULL;

    cout << "虚函数表地址:" << (int*)(&b) << endl;

    cout << "虚函数表 — 第一个函数地址:" << (int*)*(int*)(&b) << endl;

    // Invoke the first virtual function

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

    pFun();

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

    虚函数表地址:0012FED4

    虚函数表 — 第一个函数地址:0044F148

    Base::f

    通过这个示例,我们可以看到,我们可以通过强行把&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)父类的虚函数在子类的虚函数前面。

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

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

     

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

     

    我们从表中可以看到下面几点,

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

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

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

    Base *b = new Derive();

    b->f();

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

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

     

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

     

    我们可以看到:

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

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

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

    多重继承(有虚函数覆盖)
    下面我们再来看看,如果发生虚函数覆盖的情况。

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

     

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

     

    我们可以看见,三个父类虚函数表中的f()的位置被替换成了子类的函数指针。这样,我们就可以任一静态类型的父类来指向子类,并调用子类的f()了。如:

    Derive d;

    Base1 *b1 = &d;

    Base2 *b2 = &d;

    Base3 *b3 = &d;

    b1->f(); //Derive::f()

    b2->f(); //Derive::f()

    b3->f(); //Derive::f()

    b1->g(); //Base1::g()

    b2->g(); //Base2::g()

    b3->g(); //Base3::g()

    安全性
    每次写C++的文章,总免不了要批判一下C++。这篇文章也不例外。通过上面的讲述,相信我们对虚函数表有一个比较细致的了解了。水可载舟,亦可覆舟。下面,让我们来看看我们可以用虚函数表来干点什么坏事吧。

    一、通过父类型的指针访问子类自己的虚函数

    我们知道,子类没有重载父类的虚函数是一件毫无意义的事情。因为多态也是要基于函数重载的。虽然在上面的图中我们可以看到Base1的虚表中有Derive的虚函数,但我们根本不可能使用下面的语句来调用子类的自有虚函数:

    Base1 *b1 = new Derive();

    b1->f1(); //编译出错

    任何妄图使用父类指针想调用子类中的未覆盖父类的成员函数的行为都会被编译器视为非法,所以,这样的程序根本无法编译通过。但在运行时,我们可以通过指针的方式访问虚函数表来达到违反C++语义的行为。(关于这方面的尝试,通过阅读后面附录的代码,相信你可以做到这一点)

    二、访问non-public的虚函数

    另外,如果父类的虚函数是private或是protected的,但这些非public的虚函数同样会存在于虚函数表中,所以,我们同样可以使用访问虚函数表的方式来访问这些non-public的虚函数,这是很容易做到的。

    如:

    class Base {

    private:

    virtual void f() { cout << "Base::f" << endl; }

    };

    class Derive : public Base{

    };

    typedef void(*Fun)(void);

    void main() {

    Derive d;

    Fun pFun = (Fun)*((int*)*(int*)(&d)+0);

    pFun();

    }

    结束语
    C++这门语言是一门Magic的语言,对于程序员来说,我们似乎永远摸不清楚这门语言背着我们在干了什么。需要熟悉这门语言,我们就必需要了解C++里面的那些东西,需要去了解C++中那些危险的东西。不然,这是一种搬起石头砸自己脚的编程语言。

     

    本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/qychjj/archive/2009/11/27/4887008.aspx

    展开全文
  • C++虚表

    2019-04-03 10:21:18
    标记:... 总结一下: 1,每一个有虚函数的类或者虚继承的子类都有虚表。 2,每一个子类继承父类虚表,并补充修改。 3,利用父类指针实现多态时调用的是子类的虚表。 ...

    标记:https://www.cnblogs.com/yanqi0124/p/3829964.html

    总结一下:

    1,每一个有虚函数的类或者虚继承的子类都有虚表。

    2,每一个子类继承父类虚表,并补充修改。

    3,利用父类指针实现多态时调用的是子类的虚表。

    展开全文
  • C++ 虚表

    2019-08-31 16:25:47
    每个类有个有自己的虚表 每个对象有个指针__vptr指向自己类的虚表 int main() { B bObject; A *p = & bObject; p->vfunc1(); } 在调用时 用父类的指针(这样当要指向子类时相当于自动转型) p指向b...

    每个类有个有自己的虚表  每个对象有个指针__vptr指向自己类的虚表

    int main() 
    {
        B bObject;
        A *p = & bObject;
        p->vfunc1();
    }

    在调用时 用父类的指针(这样当要指向子类时相当于自动转型) p指向bObject p调用vfunc1 会找bObject所在类的虚表

    同理:

    int main() 
    {
        A aObject;
        A *p = &aObject;
        p->vfunc1();
    }

    p去调用 aObject所在的虚表

    è¿éåå¾çæè¿°

    展开全文
  • C++虚表

    2014-03-25 20:19:59
    C++利用虚表来实现对虚函数的调用。   每个使用虚函数的class都有一张单独的虚函数表,虚函数表是在编译时候创建的静态数组。每个虚函数在虚函数表中都包含一个入口,类的实例可以调用虚函数的入口,虚函数的...
  • c++虚表

    2014-11-11 10:49:28
    C++ 函数解析   陈皓 http://blog.csdn.net/haoel     前言   C++中的函数的作用主要是实现了多态的机制。关于多态,简而言之就是用父类型别的指针指向其子类的实例,然后通过父类的指针调用实际子类的...
  • 获取C++虚表地址和虚函数地址

    万次阅读 2016-05-09 22:32:30
    获取C++虚表地址和虚函数地址  By qianghaohao  学过C++的应该都对虚表有所耳闻,在此就不过多介绍概念了,通过实例来 演示一下如何获取虚表地址和虚函数地址。  简单说一下虚表的概念:在一个类中如果有虚函数...
  • C++虚表地址和虚函数地址

    千次阅读 2019-04-12 20:17:44
    C++虚表地址和虚函数地址 虚函数是c++实现多态性的一个重要知识点,本文主要解析虚函数在内存中的地址,以及与虚表地址的关系。 声明一个类,包含两个虚函数,一个普通成员函数和一个类成员。 调试程序,查看...
  • 学过C++的应该都对虚表有所耳闻,在此就不过多介绍概念了,通过实 例来演示一下如何获取虚表地址和虚函数地址。 简单说一下虚表的概念:在一个类中如果有虚函数,那么此类的实例中就有一个虚表指针指向虚表,这个...
  • 深入C++虚表

    2013-08-24 15:32:22
    福建电脑 2010年第2期(下转第76页)   深入C++虚表  
  • 多态是C++语言中最重要的特性之一,而虚表以及虚函数是实现多态的重要手段。许多C++语言的教材对于虚函数的使用以及调用机制有着详细的阐述,但是对于虚表的一些细节内容阐述却并不是很深,对于虚表我们可能会有很多...
  • 前言  我们说的虚表其实有很多种叫法:  · virtual method table(VMT) ...  注:笔者在本文使用C++语言,并且统一用vTable来表示虚表。  虚函数  用virtual关键字修饰的函数叫虚函数。  
  • C++虚表结构详解

    千次阅读 2018-12-14 00:06:03
    为了实现虚函数,C++使用动态绑定方式,称为虚表虚表是一个包含函数的查找表,该查找表用于动态绑定方式解决函数调用问题,虚表有时候被称为“vtable”,"虚函数表",“虚方法表”,“分派表”。 ...
  • c++虚表指针更新

    2019-01-03 19:10:03
    0x00 最近分析了一个dump,和虚函数表的指针有关系,总结下。 Debug下编译,exe拖进IDA分析。 0x01 CI虚表: CC虚表: ...我们知道c++的纯虚类无法被实例化,原因很有可能就是纯虚类对象的虚表...
  • //演示一下c++如何找到虚表地址vptr以及如何通过虚表调用虚函数  #include &lt;iostream&gt;  using namespace std;  class CTest  {  public:  CTest(){}  virtual void Print(){cout&lt;&...
  • C++ 虚表 & 多态的实现原理

    千次阅读 多人点赞 2019-11-06 21:17:18
    虚函数指针和虚表是什么 继承中的虚表 单继承中的虚表 多继承中的虚表 多态的原理 小结 相关博客: 1. 关于C++继承的博客 戳链接( ̄︶ ̄)↗https://blog.csdn.net/qq_41071068/article/details/102868477...
  • C++虚表详解

    千次阅读 2019-09-03 17:24:04
    C++中,虚函数表并不独立存在,而是存在于虚表中 下面就通过例子来解析虚表的结构,以32位操作系统为例: class A { public: int a_; virtual void foo1() { cout ; } virtual void foo2() { cout ; } ...
  • C++虚表的机制

    2017-08-07 10:10:35
    1。虚表是在编译时期创建的。 2。在运行时,创建对象的时候,同时创建一个指向虚表的指针。首先看是不是虚函数,如果是虚函数,那么就去查询虚表。找到符合实际对象实际类型的函数,并执行。
  • 面向对象语言的三大特性:继承、封装、多态 其中多态的含义是同一方法的具体执行与实际调用者上下文环境密切有关... 动态多态:主要依靠函数来实现,不同的编译器其函数实现原理不同 函数的基本使用方法: .

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,249
精华内容 2,899
关键字:

c++虚表

c++ 订阅