虚函数表的实现

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

参考：http://blog.csdn.net/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();
}

小虾米qq
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
简述虚函数表
wufeifan_learner的博客
04-04 6292
前段时间我在博客中简单地说了下C++的虚函数，所谓虚函数，就是C++实现多态性的方法。那么编译器是如何识别虚函数的呢？据百度百科描述，C++并未规定用何种方法实现虚函数，但是大部分编译器厂商都选择使用虚函数表这种方法，那到底什么是虚函数表？？？ 虚函数表，称为V-Table。虚函数表是一片连续的内存区域，每个内存单元存放着JMP指令地址。 看到这里，可能会比较懵逼，啥是内存单元，啥是JM...
虚函数表(图文详解)
最新发布
originalHSL的博客
10-31 1598
本文讲解了虚函数表以及继承和多态常见的面试问题
c++虚函数表、地址详解
papaya的博客
07-14 1352
c++虚函数表详解
C++：多态的底层实现原理 -- 虚函数表
weixin_43908419的博客
04-14 1275
本文结合内存监视窗口和虚表打印函数，分析了多态实现的底层原理，并给出了单继承和多继承体系中的内存模型。
c++ - 虚函数表
weixin_49303682的博客
12-23 2254
1.什么是虚函数表 所谓虚函数表就是存放着当前类中所有虚函数地址的表。在实例化一个具有虚函数的类时，这个表 也被分配到这个实例对象的内存中，通过虚函数表可以指明所要调用的函数的位置。在C++编译器 中虚函数表的地址存放在对象的最前面，这是为了即使多继承下也能快速获取到虚函数表。 代码示例： class Base{ public: virtual void A(){cout << "Base::A()" << endl;} virtual void B(){cout &
C++虚函数表解析
03-03
前言C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型...
C++虚函数表实例分析
09-04
C++虚函数表是实现多态性的重要机制，它允许我们通过基类指针或引用调用派生类中的重写方法。在这个实例分析中，我们将深入探讨虚函数表的工作原理，以及如何通过代码来查看和理解它们。 首先，多态性是面向对象...
C++类对象关于虚函数表详解
03-14
本文将深入探讨虚函数的实现机制——虚函数表（V-Table）。 虚函数表，也称为V-Table，是C++实现多态性的核心。它是一个类的虚函数地址列表，存储在每个具有虚函数的对象实例内存中。当使用基类指针操作派生类对象...
c语言tips-c语言的虚函数实现
留下虚度光阴的一些证据。
09-03 897
学过面对对象的同学都知道虚函数是面向对象编程中的一个重要概念，它允许在基类和派生类之间实现多态性（polymorphism）。我们可以在基类去定义一个成员函数，然后再派生类再去覆盖写它，这样在不同派生类使用相同函数名就可以实现不同的功能。下面可以看一下c++和python是如何做的虽然c语言是个面向过程的语言，但是使用属性依旧能够实现面向对象的虚函数的概念，在某些场合中对于整体代码的维护和开发有着重大作用。全网好像也没有比较详细的对__attribute__((weak))属性。
虚函数的实现原理
Pichairen
03-10 6696
虚函数的实现原理： 虚函数的用法：可以让派生类重写基类的成员函数实现多态。虚函数实现多态的机制，严格来说是动态多态，是在出现运行的时候实现的。 虚函数的实现原理：每个虚函数都会有一个与之对应的虚函数表，该虚函数表的实质是一个指针数组，存放的是每一个对象的虚函数入口地址。对于一个派生类来说，他会继承基类的虚函数表同时增加自己的虚函数入口地址，如果派生类重写了基类的虚函数的话，那么继承过来的虚函...
虚函数表的原理
qq_38107231的博客
03-03 389
c++虚函数表的说明
纯C语言简单模拟C++的虚函数表
smstong的成长轨迹
02-15 7861
多态，面向接口编程等设计方法并没有绑定到任何特定的语言上，使用纯C也可以实现简单的多态概念。下面给出一个非常简单粗糙的例子，只为说明概念。 父类Animal定义 文件：animal.h#ifndef ANIMAL_H #define ANIMAL_H /* 方法表, 类似于C++的虚函数表 */ typedef struct vtable vtable; struct vtable { v
c++面试题2：虚函数是如何实现的？
Voidwalkerxiaohui
09-08 4931
c++面试题2：虚函数是如何实现的？ 1、虚函数如何实现的？ 虚函数是通过一张虚函数表实现的，有多少个虚函数，就有多少个指针；在这个表中，主要是一个类的虚函数的地址表，这张表解决了继承、覆盖的问题；实际上在编译的时候，编译器会自动加上虚表虚函数的作用实现动态联编，也就是说在程序运行阶段动态的选择合适的成员函数，在定义了虚函数之后，可以在基类的派生类中对虚函数重新定义。虚表的使用方法是如
C++虚函数表详解
热门推荐
amoscykl的博客
01-05 1万+
C++的虚函数(Virtual Function)是通过一张虚函数表(Virtual Table)来实现的。简称为V-Table。在这个表中，主要是一个类的虚函数的地址表，这张表解决了继承、覆盖(override)的问题，保证其能真实的反应实际的函数。这样，在有虚函数的类的实例中这张表被分配在了这个实例的内存中，所以当我们用父类的指针操作一个子类的时候，这张虚函数表就显得尤为重要了，他就像一个地...
虚函数（虚函数表vtable)的实现
bigman1988的专栏
09-12 513
一个动态的链接究竟怎样实现的呢？    首先，如果一个基类中有虚函数，则编译器自动生成一个指向虚函数地址的表。有 几个虚函数，对应的虚函数表(vftable)的长就是几。    然后，在基类中生成一个指向虚函数表的指针。    对应的每个虚函数由编译器将其映射为虚函数表指
C++虚函数表剖析
qq_27695961的博客
07-04 328
关键词：虚函数，虚表，虚表指针，动态绑定，多态 一、概述 为了实现C++的多态，C++使用了一种动态绑定的技术。这个技术的核心是虚函数表（下文简称虚表）。本文介绍虚函数表是如何实现动态绑定的。 二、类的虚表 每个包含了虚函数的类都包含一个虚表。  我们知道，当一个类（A）继承另一个类（B）时，类A会继承类B的函数的调用权。所以如果一个基类包含了虚函数，那么其继承类也可调用
虚函数实现的基本原理
Lce的专栏
08-18 212
每一个含有虚函数(无论是其本身就含有的，还是从基类继承过来的)的类都至少有一个与之对应的虚函数表，其中存放着该类所有的虚函数对应的函数指针。如下图所示：B的虚函数表中存放着B::foo和B::bar两个函数指针D的虚函数表中存放的既有继承自B的虚函数B::foo，又有重写了基类虚函数B::bar的D::bar，还有新增的虚函数D::quz。......
[程序员面试]C++虚函数表详细解释及实例分析
leo115的专栏
10-01 9927
C++的虚函数(Virtual Function)是通过一张虚函数表(Virtual Table)来实现的。简称为V-Table。在这个表中，主要是一个类的虚函数的地址表，这张表解决了继承、覆盖(override)的问题，保证其能真实的反应实际的函数。这样，在有虚函数的类的实例中这张表被分配在了这个实例的内存中，所以当我们用父类的指针操作一个子类的时候，这张虚函数表就显得尤为重要了，他就像一个地图
C++多态调用实现原理（虚函数表详解)
shanghx_123的博客
10-11 4540
1.带有虚函数的对象模型 我们先看段代码： #include&amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;iostream&amp;amp;amp;amp;amp;amp;amp;amp;amp;gt; using namespace std; class B1 { public: void func1() {} int _b; }; class B2 { public: virtual void func()
深入理解C++多态与虚函数表
虚函数表（Virtual Table，简称VTBL）是C++实现动态绑定（也称为运行时多态）的关键机制。每个包含虚函数的类都有一个虚函数表，其中存储了类中虚函数的地址。当通过基类指针调用虚函数时，编译器会在运行时查找对应...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值