虚函数表的实现

最新推荐文章于 2025-03-09 15:28:11 发布
最新推荐文章于 2025-03-09 15:28:11 发布
阅读量394 收藏 1
点赞数
分类专栏： 虚函数专题 文章标签： 虚函数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_36150323/article/details/77482411
版权

参考：http://blog.youkuaiyun.com/haoel/article/details/1948051/

#include<iostream>
#include<string>

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; }
};
int main()
{
    typedef void(*Fun)(void);
    Base b;
    Fun pFun = NULL;
    cout << "虚函数表的地址" << (int*)(&b) << endl;
    cout << "虚函数表-第一个函数的地址" << (int*)*(int*)(&b) << endl;
    pFun = (Fun)*((int*)*(int*)(&b));
    pFun();
    pFun = (Fun)*((int*)*(int*)(&b) + 1);
    pFun();
    pFun = (Fun)*((int*)*(int*)(&b) + 2);
    pFun();

    return  0;
}

这里写图片描述
一般继承，没有虚函数覆盖
假设继承关系如下图所示：
这里写图片描述

注意点
1、在这个继承关系中，子类没有重载任何父类函数。那么，在派生类的实例中，虚函数表如下图所示：
对于实例：Derive d；的虚函数表如下图所示：
这里写图片描述

#include<iostream>
#include<string>

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 Derived:public Base
{
    virtual void f1(){ cout << "Base::f1" << endl; }
    virtual void g1(){ cout << "Base::g1" << endl; }
    virtual void h1(){ cout << "Base::h1" << endl; }
};
int main()
{
    typedef void(*Fun)(void);
    //Base b;
    Derived b;
    Fun pFun = NULL;
    cout << "虚函数表的地址" << (int*)(&b) << endl;
    cout << "虚函数表-第一个函数的地址" << (int*)*(int*)(&b) << endl;
    pFun = (Fun)*((int*)*(int*)(&b));
    pFun();
    pFun = (Fun)*((int*)*(int*)(&b) + 1);
    pFun();
    pFun = (Fun)*((int*)*(int*)(&b) + 2);
    pFun();
    pFun = (Fun)*((int*)*(int*)(&b) + 3);
    pFun();
    pFun = (Fun)*((int*)*(int*)(&b) + 4);
    pFun();
    pFun = (Fun)*((int*)*(int*)(&b) + 5);
    pFun();

    return  0;
}

这里写图片描述
一般继承（有虚函数覆盖）
子类虚函数重载父类虚函数
这里写图片描述
对于派生实例
这里写图片描述
注意点
1）派生类的f()函数被放到了原来基类函数的位置
2）其他函数依旧如此

#include<iostream>
#include<string>

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 Derived:public Base
{
    virtual void f1(){ cout << "Base::f1" << endl; }
    virtual void g1(){ cout << "Base::g1" << endl; }
    virtual void h1(){ cout << "Base::h1" << endl; }
};
int main()
{
    typedef void(*Fun)(void);
    //Base b;
    Derived b;
    Fun pFun = NULL;
    cout << "虚函数表的地址" << (int*)(&b) << endl;
    cout << "虚函数表-第一个函数的地址" << (int*)*(int*)(&b) << endl;
    pFun = (Fun)*((int*)*(int*)(&b));
    pFun();
    pFun = (Fun)*((int*)*(int*)(&b) + 1);
    pFun();
    pFun = (Fun)*((int*)*(int*)(&b) + 2);
    pFun();
    pFun = (Fun)*((int*)*(int*)(&b) + 3);
    pFun();
    pFun = (Fun)*((int*)*(int*)(&b) + 4);
    pFun();
    /*pFun = (Fun)*((int*)*(int*)(&b) + 5);
    pFun();*/

    return  0;
}

这里写图片描述

则就能实现用基类的指针指向派生类的函数

Base *b=new Derived();
b->fun();

由于对象b的虚函数表中f()的位置已经被派生类的f()所取代，于是在实际调用发生的时候，则运行的是派生类的函数，就实现了多态。
多重继承（无虚函数覆盖）
这里写图片描述

对于子类实例中的虚函数表，是下面这个样子：
这里写图片描述
总结
1）每个基类都有自己的虚表
2）子类的成员函数被放到了第一个父类的表中

这样做的目的：
解决不同的父类类型的指针指向同一个自雷示例，从而能调用到实际的函数

#include<iostream>
#include<string>

using namespace std;

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

class Derived :public Base1,Base2,Base3
{
    virtual void f1(){ cout << "Base::f1" << endl; }
    virtual void g1(){ cout << "Base::g1" << endl; }
    virtual void h1(){ cout << "Base::h1" << endl; }
};
int main()
{
    typedef void(*Fun)(void);
    //Base b;
    Derived b;
    Fun pFun = NULL;
    cout << "虚函数表的地址" << (int*)(&b) << endl;
    cout << "虚函数表-第一个函数的地址" << (int*)*(int*)(&b) << endl;
    pFun = (Fun)*((int*)*(int*)(&b));
    pFun();
    pFun = (Fun)*((int*)*(int*)(&b) + 1);
    pFun();
    pFun = (Fun)*((int*)*(int*)(&b) + 2);
    pFun();
    pFun = (Fun)*((int*)*(int*)(&b) + 3);
    pFun();
    pFun = (Fun)*((int*)*(int*)(&b) + 4);
    pFun();
    /*pFun = (Fun)*((int*)*(int*)(&b) + 5);
    pFun();*/

    Base1 *ptr1 = new Derived();
    ptr1->f();

    Base2 *ptr2 = new Derived();//错误不允许对不可访问的基类进行转换
    ptr1->f();

    Base3 *ptr3 = new Derived();//错误不允许对不可访问的基类进行转换
    ptr1->f();

    return  0;
}

e:\c++\project\多重继承（无虚函数覆盖）\多重继承（无虚函数覆盖）\源.cpp(58): error C2243: “类型转换”: 从“Derived ”到“Base2 ”的转换存在，但无法访问
可以的：

Derived b;
Base1 *ptr1 = new Derived();
ptr1->f();

Base2 *ptr2 =NULL;
ptr1->f();

/*Base3 *ptr3 = new Derived();
ptr1->f();
*/
return  0;

结果Base：：1
Base：：1

多重继承（有虚函数覆盖）
面我们再来看看，如果发生虚函数覆盖的情况。

下图中，我们在子类中覆盖了父类的f()函数
这里写图片描述
下面是对于子类实例中的虚函数表的图
这里写图片描述

#include<iostream>
#include<string>

using namespace std;

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

class Derived :public Base1,Base2,Base3
{
    virtual void f(){ cout << "Base::f1" << endl; }
    virtual void g1(){ cout << "Base::g1" << endl; }
    virtual void h1(){ cout << "Base::h1" << endl; }
};
int main()
{
    typedef void(*Fun)(void);
    //Base b;
    Derived b;
    Fun pFun = NULL;
    cout << "虚函数表的地址" << (int*)(&b) << endl;
    cout << "虚函数表-第一个函数的地址" << (int*)*(int*)(&b) << endl;
    pFun = (Fun)*((int*)*(int*)(&b));
    pFun();
    pFun = (Fun)*((int*)*(int*)(&b) + 1);
    pFun();
    pFun = (Fun)*((int*)*(int*)(&b) + 2);
    pFun();
    pFun = (Fun)*((int*)*(int*)(&b) + 3);
    pFun();
    pFun = (Fun)*((int*)*(int*)(&b) + 4);
    pFun();
    /*pFun = (Fun)*((int*)*(int*)(&b) + 5);
    pFun();*/

    Base1 *ptr1 = new Derived();
    ptr1->f();

    Base2 *ptr2 = new Derived();
    ptr1->f();

    Base3 *ptr3 = new Derived();
    ptr1->f();

    return  0;
}

1>e:\c++\project\多重继承（无虚函数覆盖）\多重继承（无虚函数覆盖）\源.cpp(58): error C2243: “类型转换”: 从“Derived ”到“Base2 ”的转换存在，但无法访问
这样可以

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

    Base1 *ptr1 = new Derived();
    ptr1->f();

    Base2 *ptr2 =NULL;
    ptr1->f();

    /*Base3 *ptr3 = new Derived();
    ptr1->f();
*/
    return  0;

这里写图片描述

安全性：

一、通过父类型的指针访问子类自己的虚函数
我们知道，子类没有重载父类的虚函数是一件毫无意义的事情。因为多态也是要基于函数重载的。虽然在上面的图中我们可以看到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++虚函数表实现详细解析 (附示例)
enchanted的博客
05-15 2998
相信很多人在了解到多态之后，都想要知道其具体的实现原理。其实大家应该都或多或少地知道：`虚函数是通过虚函数表实现的`。但是呢，可能和我之前一样，知道大概是怎样的，但是没有通过代码真正地运行测试。最近我也在网上查看了一番，发现有的文章写得很好，但是代码上面可能欠考虑一点，有的则是没有详细解释。因此本文将使用详细示例来探讨虚函数的实现原理，教你如何通过对象查找虚函数地址并调用。末尾还会分享一些没有用但好玩的技巧。
纯C语言简单模拟C++的虚函数表
smstong的成长轨迹
02-15 7989
多态，面向接口编程等设计方法并没有绑定到任何特定的语言上，使用纯C也可以实现简单的多态概念。下面给出一个非常简单粗糙的例子，只为说明概念。 父类Animal定义 文件：animal.h#ifndef ANIMAL_H #define ANIMAL_H /* 方法表, 类似于C++的虚函数表 */ typedef struct vtable vtable; struct vtable { v
虚函数表又是怎样实现的？
渴死的火烈鸟
09-20 287
每个含有虚函数的类有一张虚函数表(vtbl)，表中每一项指向一个虚函数的地址，实现上是一个函数指针的数组。 虚函数表既有继承性又有多态性。每个派生类的vtbl继承了它各个基类的vtbl，如果基类vtbl中包含某一项，则其派生类的vtbl中也将包含同样的一项，但是两项的值可能不同。如果派生类覆盖(override)了该项对应的虚函数，则派生类vtbl的该项指向重载后的虚函数，没有重载的话，则沿...
大厂面试必考！C++ 多态底层原理 + 虚函数表，5 分钟看懂！
最新发布
Henry313的博客
03-09 890
大厂面试必考！C++ 多态底层原理 + 虚函数表，5 分钟看懂！
C++中虚函数、虚指针和虚表详解
bob的博客
09-28 5900
关于虚函数的背景知识 用virtual关键字申明的函数叫做虚函数，虚函数肯定是类的成员函数。 存在虚函数的类都有一个一维的虚函数表叫做虚表。每一个类的对象都有一个指向虚表开始的虚指针。虚表是和类对应的，虚表指针是和对象对应的。 多态性是一个接口多种实现，是面向对象的核心。分为编译多态性和运行多态性。 运行多态用虚函数来实现，结合动态绑定。 纯虚函数是虚函数再加上=0。并且该函数只有声明，没有实现。 抽象类是指包括至少一个纯虚函数的类。 详细原理： 编译器在编译的时候，发现Base类中有虚函数，此时编译器
什么是虚函数表（vtable）？它是如何在 C++ 中实现的？
qiuyehuanghun的博客
02-20 4237
当调用 obj.func1() 和 obj.func2() 时，编译器通过 obj 的虚函数指针找到对应的虚函数表，然后根据虚函数的索引找到对应的虚函数的地址，并调用该函数。当调用 obj.func1() 和 obj.func2() 时，编译器通过 obj 的虚函数指针找到对应的虚函数表，然后根据虚函数的索引找到对应的虚函数的地址，并调用该函数。在编译阶段，对于每个包含虚函数的类，编译器会在代码中生成虚函数表，并将虚函数的地址填充到表中。然后，通过虚函数表中的索引找到对应的虚函数的地址，并调用该函数。
虚函数及其实现
Krena_xux的博客
03-20 1474
虚函数可以在运行的过程中动态编联，根据指针所指的对象，调用对应的函数 成为虚函数必须满足两个条件： 1.函数依赖于对象调用：因为虚函数是存储在虚函数表中，有一个虚函数指针指向虚函数表，要调用虚函数必须通过虚函数指针，虚函数指针是存储在对象中的。 2.函数必须可寻址，因为虚函数表中存放的是虚函数的入口地址 不能成为虚函数的函数 1.内联函数：在内联函数的调用点将其展开，不能产生函数符号，所以不能把它...
C++虚函数表实现机制解析
虚函数表是C++实现多态性的一个关键机制，主要用于解决动态绑定问题，确保通过基类指针调用子类重写的成员函数时能正确执行子类的实现。在C++中，当一个类声明了虚函数，编译器就会为这个类生成一张虚函数表，表中...
C++虚函数表测试源码
10-12
这种动态绑定功能是通过虚函数表实现的。 虚函数表是一个由编译器自动生成的内部数据结构，存储了类中虚函数的地址。每个具有虚函数的类都有一个虚函数表，且每个类对象在内存中都会包含一个指向该表的指针。当通过...
C++虚函数表实现聚合(COM)
03-12
在C++编程语言中，虚函数表（Virtual Function Table，简称VFT或VTbl）是实现多态性的重要机制，特别是在面向对象编程中。多态性允许子类重写父类的方法，使得相同的消息可以有不同的行为。虚函数表是这种功能的底层...
C++虚函数及虚函数表解析
07-24
C++的虚函数和虚函数表是面向对象编程中实现多态性的重要机制。多态性允许通过基类指针或引用调用不同子类的重写方法，从而实现更灵活的设计和代码复用。 虚函数（Virtual Function）是基类中声明的一种特殊函数，...
虚函数表实现机制
clam_clam的专栏
10-31 2040
对C++ 了解的人都应该知道虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）来实现的。简称为V-Table。 在这个表中，主是要一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其容真实反应实际的函数。这样，在有虚函数的类的实例中这个表被分配在了 这个实例的内存中，所以，当我们用父类的指针来操作一个子类的时候，这张虚函数表就显得由为重要了，它就像一
C++之深入解析虚函数表的实现及其内存布局
╰つ栺尖篴夢ゞ
04-17 1366
C++ 中的虚函数的作用主要是实现了多态的机制，关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数：Derive d;b1 -> f();这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，就是试图使用不变的代码来实现可变的算法。比如：模板技术，RTTI 技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议。
c++虚函数表实现（转载）
cybermerman的专栏
07-24 578
C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技术，RTTI技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议。 关于虚函数的使用方法，我在这里不做过
C++ 虚函数实现：虚函数表 虚表指针
Poundssss的博客
09-24 2539
virtual（虚函数）的实现
C++虚函数的实现机制——虚函数表
Stoneplay
04-04 489
  C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技术，RTTI技术，虚函数技术，要么是...
C++：多态的底层实现原理 -- 虚函数表
weixin_43908419的博客
04-14 1609
本文结合内存监视窗口和虚表打印函数，分析了多态实现的底层原理，并给出了单继承和多继承体系中的内存模型。
虚函数和虚函数表 - 多态的实现原理
Andrea-地面宇航员
09-03 163
虚函数和虚函数表 - 多态的实现原理 虚函数表 C++中虚函数是通过一张虚函数表（virtual table）来实现的，在这个表中，主要是一个类的虚函数的地址表，这张表解决了继承、覆盖的问题 在有虚函数的类的实例中这个表被分配在了这个对象的内存中，所以当我们用父类的指针来操作一个子类的时候，这张虚函数表就像一张地图一样指明了实际所应该调用的函数 #include<iostream> using namespace std; class Base { public: virtual
类虚函数表原理实现分析
谢绝(无视)留言与私信
12-19 1224
原理分析 当调用一个虚函数时, 编译器生成的代码会调用 虚表地址[0](param1, param2)这样的函数. 已经不是在调用函数名了. 当我们将虚表地址[n]中的函数实现改为另外的函数, 虚函数的实现就由我们来控制了. 实验 根据虚表原理, 实验一下修改自己程序的虚函数表项地址.  使编译器生成的代码执行一个虚函数A时, 执行的是我们自己定义的非虚函数B. 知识点
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值