zoukankan      html  css  js  c++  java
  • <转载>C++函数指针,C++ 虚函数表解析

    虚函数表算是面试官最爱问的C++问题了,如果你的简历提到熟悉C++而关于虚函数机制没有回答好,那么你就会被怀疑。。。:)
    我觉得虽然理解虚函数表不是编程必须的,但是了解一下还是有帮助的,侯捷翻译的<<Inside C++ model>>应该是最详细解释所有这些的了。不过网上有很多很好的资源,
    主要为了查阅方便,另外转载http://www.pconline.com.cn/pcedu/empolder/gj/c/0503/566020.html管宁写的关于函数指针写的很清楚。
    另外关于C++虚函数解析需要补充的是作者为了实现清晰,没有提到c++的this指针, 对于 Base.f()其实它的原型是类似f(Base* this)的函数,由于作者用了
    强制类型转换所以用了typedef void(*Fun)(void); 如果f()函数中会访问到Base的数据成员,那么结果显然是不对的。可以用typedef void(*Fun2)(int *);
    或者typedef void(*Fun3)(Base *); 
    class Base {
        public:
            Base():x(3), y(4){}

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

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

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

            int x;
            int y;
    };

       Base b;
        Fun2 pfun2;
        pfun2 = (Fun2)*((int *)*(int *)(&b));
        pfun2((int *)&b);
        
        Fun3 pfun3;
        pfun3 = (Fun3)*((int *)*(int *)(&b));
        pfun3(&b);
    这样产生的结果才会和Base base; base.f()完全相同,显示3,而利用typedef void(*Fun)(void),结果是 -1209178304
    (当然因为作者给的例子中f()函数中没有访问对象数据成员,结果也就不会出错,作者仅仅是为了演示虚函数表的实现。)
    另外实验了下,虚函数表的指针会占用对象的第一个位置,之后是对象数据,上面的例子中x,然后是y。
    虚函数表每个类拥有一个,相同的类不同实例对象的虚函数表指针都指向相同的一个虚函数表。



    C/C++中函数指针的含义

    出处:PConline 2005年03月04日 作者:管宁 责任编辑:xietaoming

      函数存放在内存的代码区域内,它们同样有地址,我们如何能获得函数的地址呢? 

    如果我们有一个int test(int a)的函数,那么,它的地址就是函数的名字,这一点如同数组一样,数组的名字就是数组的起始地址。

      定义一个指向函数的指针用如下的形式,以上面的test()为例:

    int (*fp)(int a);//这里就定义了一个指向函数的指针

      函数指针不能绝对不能指向不同类型,或者是带不同形参的函数,在定义函数指针的时候我们很容易犯如下的错误。

    int *fp(int a);//这里是错误的,因为按照结合性和优先级来看就是先和()结合,然后变成了一个返回整形指针的函数了,而不是函数指针,这一点尤其需要注意!

      下面我们来看一个具体的例子:

    #include <iostream>  
    #include <string>  
    using namespace std;  
      
    int test(int a);  
      
    void main(int argc,charargv[])    
    {  
        cout<<test<<endl;//显示函数地址  
        int (*fp)(int a);  
        fp=test;//将函数test的地址赋给函数学指针fp  
        cout<<fp(5)<<"|"<<(*fp)(10)<<endl;  
    //上面的输出fp(5),这是标准c++的写法,(*fp)(10)这是兼容c语言的标准写法,两种同意,但注意区分,避免写的程序产生移植性问题!  
        cin.get();  
    }  
      
    int test(int a)  
    {  
        return a;  
    }

      typedef定义可以简化函数指针的定义,在定义一个的时候感觉不出来,但定义多了就知道方便了,上面的代码改写成如下的形式:

    #include <iostream>  
    #include <string>  
    using namespace std;  
      
    int test(int a);  
      
    void main(int argc,charargv[])    
    {  
        cout<<test<<endl;  
        typedef int (*fp)(int a);//注意,这里不是生命函数指针,而是定义一个函数指针的类型,这个类型是自己定义的,类型名为fp  
        fp fpi;//这里利用自己定义的类型名fp定义了一个fpi的函数指针!  
        fpi=test;  
        cout<<fpi(5)<<"|"<<(*fpi)(10)<<endl;  
        cin.get();  
    }  
      
    int test(int a)  
    {  
        return a;  
    }


    C++ 虚函数表解析

     

    陈皓

    http://blog.csdn.net/haoel

     

     

    前言

     

    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++中那些危险的东西。不然,这是一种搬起石头砸自己脚的编程语言。

     

    在文章束之前还是介绍一下自己吧。我从事软件研发有十个年头了,目前是软件开发技术主管,技术方面,主攻Unix/C/C++,比较喜欢网络上的技术,比如分布式计算,网格计算,P2PAjax等一切和互联网相关的东西。管理方面比较擅长于团队建设,技术趋势分析,项目管理。欢迎大家和我交流,我的MSNEmail是:haoel@hotmail.com 

     

    附录一: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;

    }

     

  • 相关阅读:
    敏捷社区--干货下载 | 10月携程敏捷总动员沙龙
    敏捷开发--洞察敏捷模型,从PO的角度看敏捷产品管理
    携程PMO--小罗说敏捷之WIP限制在制品
    Jmeter分布式压测配置
    Django安装
    Git安装与配置,以及pycharm提交代码到github
    SVN状态图标不显示的解决办法
    PyCharm专业版激活+破解到期时间2100年
    部署python项目到linux服务器
    python+selenium自动化测试,浏览器最大化报错解决方法
  • 原文地址:https://www.cnblogs.com/rocketfan/p/1569294.html
Copyright © 2011-2022 走看看