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; }

};

int main()
{
    //freopen("input.txt","r",stdin);

    typedef void(*Fun)(void);
    Base b;

    Fun pFun = NULL;

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

    // Invoke virtual functions

    pFun = (Fun)*((int*)*(int*)(&b));  // Base::f()
    pFun();
    pFun = (Fun)*((int*)*(int*)(&b)+1);  // Base::g()
    pFun();
    pFun = (Fun)*((int*)*(int*)(&b)+2);  // Base::h()
    pFun();

    return 0;
}

vs2012 环境下输出：

通过这个示例，我们可以看到，我们可以通过强行把 &b 转成 int*，取得虚函数表的地址，然后，再次取址就可以得到第一个虚函数的地址了，也就是Base::f()，这在上面的程序中得到了验证（把int* 强制转成了函数指针）。

Base 实例虚表结构图如下：

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

而且，只要继承父类的虚函数，其子类不论写不写virtual都是虚函数。

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

};

class Base2 : public Base{
public:
    void f() { cout << "Base2::f" << endl; }
};

class Derive : public Base2{

public:
    void f() { cout << "Derive::f" << endl; }
};

typedef void(*Fun)(void);

int main() {
    Base2 *b2 = new Derive;

    b2->f();

    return 0;
}

输出：

Derive::f

三、不同情况下的虚表

下面没有覆盖父类的虚函数是毫无意义的。之所以要讲述没有覆盖的情况，主要目的是为了给一个对比。在比较之下，可以更加清楚地知道其内部的具体实现。

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

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

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

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

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

对于派生类的实例，其虚函数表为

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

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

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

对于子类实例中的虚函数表为

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

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

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

子类虚函数结构

    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()

问：那子类和父类虚函数表维护的是一样的吗？或者说上面子类自己的虚函数放在自己的表中吗？

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

class Derive:public Base
{
public:
    void f(){ cout << "Derive::f" << endl; }
    virtual void f1() { cout << "Derive::f1" << endl; }

};

int main()
{
    //freopen("input.txt","r",stdin);

    typedef void(*Fun)(void);

    Base b;
    Fun bFun = (Fun)*((int*)*(int*)(&b));
    bFun();
    bFun = (Fun)*((int*)*(int*)(&b)+1);
    bFun();
    cout<<bFun<<endl;

    Derive d;
    Fun dFun = (Fun)*((int*)*(int*)(&d));
    dFun();
    dFun = (Fun)*((int*)*(int*)(&d)+1);
    dFun();
    dFun = (Fun)*((int*)*(int*)(&d)+2);
    dFun();
    cout<<dFun<<endl;

    return 0;
}

四、虚函数表安全性

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

我们知道，子类没有覆盖父类的虚函数是一件毫无意义的事情。虽然在上面的图中我们可以看到 Base1 的虚表中有Derive的虚函数，但我们根本不可能使用下面的语句来调用子类的自有虚函数：

Base1 *b1 = new Derive();
b1->f1();  //编译出错

任何妄图使用父类指针想调用子类中的未覆盖父类的成员函数的行为都会被编译器视为非法，所以，这样的程序根本无法编译通过。但在运行时，我们可以通过指针的方式访问虚函数表来达到违反C++语义的行为。

下面的例子就可以做到。

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

#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;
}

2、访问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();
}

VC查看虚函数表

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

附：基础回顾

1、多态

概念：

多态性就是指同样的消息被类的不同的对象接收时导致的完全不同的行为的一种现象。这里所说的消息即对类成员函数的调用。多态实质是一个函数名称的多种形态。

C++两种类型多态：

（1）编译时多态是通过静态联编实现的；

（2）运行时多态则是通过动态联编实现的。

函数联编：

对一个函数的调用，在编译或运行时确定将其连接到相应的函数体的代码，实质是把一个标示名与一个存储地址（函数代码段入口）联系在一起的过程。

2、虚函数

C++中的动态联编是通过虚函数实现的，虚函数必须存在于继承的环境下。

当一个类的成员函数说明为虚函数后，就可以在该类的（直接或间接）派生类中定义与其基类虚函数原型相同（注意是函数原型一定要完全相同，否则会隐藏该虚函数）的函数。

虚函数可以在一个或多个派生类中被重新定义，要求在派生类中重新定义时，必须与基类中的函数原型完全相同，包括函数名、返回类型、参数个数和参数类型的顺序。这时无论在派生类的相应成员函数前是否加上关键字virtual，都将视其为虚函数，如果函数原型不同，只是函数名相同，C++将视其为一般的函数重载，而不是虚函数。只有类的成员函数才能声明为虚函数，全局函数及静态成员函数不能声明为虚函数。

3、纯虚函数

纯虚函数是在基类中只声明虚函数而不给出具体的函数定义体，将它的具体定义放在各派生类中，称此虚函数为纯虚函数。

通过该基类的指针或引用就可以调用所有派生类的虚函数，基类只是用于继承，仅作为一个接口，具体功能在派生类中实现.

纯虚函数的声明如下：（注：要放在基类的定义体中）

   virtual 函数原型=0；

注意：

（1）声明了纯虚函数的类，称为抽象类；

（2）抽象类中可以有多个纯虚函数；

（3）不能声明抽象类的对象，但可以声明指向抽象类的指针变量和引用变量；

（4）抽象类也可以定义其他非纯虚函数；

（5）如果派生类中没有重新定义基类中的纯虚函数，则在派生类中必须再将该虚函数声明为纯虚函数；

（6）从抽象类可以派生出具体或抽象类，但不能从具体类派生出抽象类（这条在vs2012上实验是错误的，详见后面代码）；

（7）在一个复杂的类继承结构中，越上层的类抽象程度越高，有时甚至无法给出某些成员函数的实现，显然，抽象类是一种特殊的类，它一般处于类继承结构的较外层；

（8）引入抽象类的目的，主要是为了能将相关类组织在一个类继承结构中，并通过抽象类来为这些相关类提供统一的操作接口。

验证第六条：

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

};

class Base2 : public Base{
public:
    virtual void g()=0;
};

class Derive : public Base2{

public:
    void g() { cout << "Derive::g" << endl; }
};

int main() {
    Base2 *b2 = new Derive;

    b2->f();
    b2->g();

    return 0;
}

最后输出：

Base::f

Derive::g

说明也可以从具体类派生抽象类。

参考资料

[1] http://my.oschina.net/hnuweiwei/blog/280894?fromerr=4qwE4QQr

[2] http://blog.csdn.net/haoel/article/details/1948051

时间： 2024-12-25 17:43:16

C++之：虚函数表的相关文章

单继承与多继承中的虚函数表和虚函数指针

首先,我们了解一下何为单继承,何为多继承?? 单继承:一个子类只有一个直接父类. 多继承:一个子类有两个或多个直接父类. 单继承中的虚函数表分析: 示例程序: #include <iostream> using namespace std; typedef void(*FUNC)(); class Base { public: virtual void func1() { cout << "Base::func1()" << endl; } virt

C++ 虚函数表解析

转自陈浩的博客 前言 C++中的虚函数的作用主要是实现了多态的机制.关于多态,简而言之就是用父类型的指针指向其子类的实例,然后通过父类的指针调用实际子类的成员函数.这种技术可以让父类的指针有"多种形态",这是一种泛型技术.所谓泛型技术,说白了就是试图使用不变的代码来实现可变的算法.比如:模板技术,RTTI技术,虚函数技术,要么是试图做到在编译时决议,要么试图做到运行时决议. 关于虚函数的使用方法,我在这里不做过多的阐述.大家可以看看相关的C++的书籍.在这篇文章中,我只想从虚函数的实现

C++虚函数表剖析

关键词:虚函数.虚表,虚表指针,动态绑定,多态 一.概述 为了实现C++的多态,C++使用了一种动态绑定的技术. 这个技术的核心是虚函数表(下文简称虚表).本文介绍虚函数表是怎样实现动态绑定的. 二.类的虚表 每一个包括了虚函数的类都包括一个虚表. 我们知道,当一个类(A)继承还有一个类(B)时.类A会继承类B的函数的调用权.所以假设一个基类包括了虚函数,那么其继承类也可调用这些虚函数,换句话说,一个类继承了包括虚函数的基类.那么这个类也拥有自己的虚表. 我们来看下面的代码. 类A包括虚函数vf

C++ 虚函数表解析（转）

转自:http://blog.csdn.net/haoel 前言 C++中的虚函数的作用主要是实现了多态的机制.关于多态,简而言之就是用父类型别的指针指向其子类的实例,然后通过父类的指针调用实际子类的成员函数.这种技术可以让父类的指针有"多种形态",这是一种泛型技术.所谓泛型技术,说白了就是试图使用不变的代码来实现可变的算法.比如:模板技术,RTTI技术,虚函数技术,要么是试图做到在编译时决议,要么试图做到运行时决议. 关于虚函数的使用方法,我在这里不做过多的阐述.大家可以看看相关的C

C++学习之虚函数表及调用规范

在支付工具想做社交,即时通讯工具想做app市场,英语字典想做新闻社交的今天,创造这些怪象的公司要求程序员懂得更多几乎是理所当然的,毕竟现在大家什么都想做.这不,正值招聘季,实验室的几位学长也是一直在讨论各种问题,发现对于C++语言而言,问的最多的还是虚函数表和STL. STL的考点至少是实用的,哪怕要求你读过源码,也并不过分,毕竟知根知底才能更好地应用.但要求程序员掌握对象模型着实拎不清,因为这几乎用不到,远没有在设计模式上投入时间实在,或许它们最希望的是拿批发价招语言专家... 我已经近2年没

类虚函数表原理实现分析（当我们将虚表地址[n]中的函数替换，那么虚函数的实现就由我们来控制了）

原理分析 当调用一个虚函数时, 编译器生成的代码会调用 虚表地址[0](param1, param2)这样的函数. 已经不是在调用函数名了. 当我们将虚表地址[n]中的函数实现改为另外的函数, 虚函数的实现就由我们来控制了. 实验 根据虚表原理, 实验一下修改自己程序的虚函数表项地址. 使编译器生成的代码执行一个虚函数A时, 执行的是我们自己定义的非虚函数B. 知识点 * 使用union赋值, 绕过编译器函数与变量强转赋值的限制 * 类成员函数指针的执行 * 修改和恢复自己的代码段属性 * 虚函

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;} }; typedef void (*Fun)(void); int main(){ Base

C++中3种多态实现机制之虚函数表

上期我们简单的讲解了利用RTTI来实现多肽,这期我们就来聊聊利用虚函数的方法来实现多肽. 1.什么是虚函数 在某基类中声明为 virtual 并在一个或多个派生类中被重新定 义的成员函数,用法格式为:virtual 函数返回类型 函数名(参数表) {函数体}:,实现多态性,通过指向派生类的基类指针或引用,访问派生类中同名覆盖成员函数 2.实现多肽的条件 简单的说就是:基类的指针或引用指向子类对象,当子类中成员函数和基类成员函数:函数名相同,参数列表相同,返回值相同,并且基类该函数为虚函数时,基类

《COM原理与应用》题外话——C++虚函数表和delete this

delete this看起来非常的奇怪,我记得在<C++ Primer>中提到过delete this,但是我已经忘了在哪了,也一直没有找到(因为没有电子版,所以一直没找到~).<C++ Primer>中提到的是在析构函数中使用delete this会造成析构函数的无限调用,最终造成栈溢出.我也在网上看了一些,很多人觉得不该使用delete this,因为会引起一些问题.但是delete this也挺有用处的,就和goto语句一样,不应该被一棍子打死(goto语句其实怪好用的:-D

关于C++中虚函数表的几点总结

虚函数表在继承层次中比较复杂,总结重要的几点如下: 1.虚函数指针一般在对象的开头或者结尾 2.虚函数表其实就是一个函数指针类型的数组 3.编译器如何知道虚函数表指针?答案是虚函数表的最后一个元素是NULL 4.当从多个基类派生时,派生类继承所有基类的虚函数指针 5.虚函数表是类级别的,类的所有对象共享同一个虚函数表 6.不同的类的对象有不同的虚函数表 7.在继承中,子类增加一个虚函数后不再单独增加一个虚函数表,而是将这个虚函数放在继承的第一个基类的虚函数表中.