C++中的虚函数以及虚函数表

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了C++中的虚函数以及虚函数表，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含6650字，纯文字阅读大概需要10分钟。

内容图文

一.虚函数的定义

被virtual关键字修饰的成员函数，目的是为了实现多态

ps：

关于多态【接口和实现分离，父类指针指向子类的实例，然后通过父类指针调用子类的成员函数，这样可以让父类指针拥有多种形态，所以称之为多态】

二.虚函数表

该表为一个类的虚函数的地址表，用于解决继承和覆盖的问题

1.拥有虚函数的类才有虚函数表

2.虚函数表属于类，然后类的所有对象通过虚函数表指针共享类的虚函数表

3.虚函数表的作用：当使用父类指针来操作子类对象时，虚函数表就像一个地图一样，指明了实际所应该调用的函数

4.c++编译器保证虚函数表的指针存在于对象实例中最前面的位置（为了保证在多层继承或者多重继承的情况下获得函数表的性能），这意味着我们可以通过对象实例的地址得到虚函数表，然后就可以遍历其中的虚函数指针，并且调用响应的虚函数

ps：多重继承：多个父类，多层继承：父类还存在父类

【通过虚函数表，遍历虚函数指针，调用响应的虚函数】

#include<bits/stdc++.h>
usingnamespace std;
class Base
{
public:
    virtualvoid f()
    {
        cout << "Base::f" << endl;
    }
    virtualvoid g()
    {
        cout << "Base::g" << endl;
    }
    virtualvoid h()
    {
        cout << "Base::h" << endl;
    }

};
typedef void(*Fun)(void);
Base b;
Fun pFun = NULL;

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

    //通过虚函数表调用虚函数
    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();
}

View Code

结果：

虚函数表地址：0x477008
虚函数表 — 第一个函数地址：0x473668
Base::f
Base::g
Base::h

View Code

以上为无继承情况

1.单层继承无虚函数覆盖的情况

1）虚函数按照声明顺序放入表中

2）父类虚函数在前，子类虚函数在后

3）末尾点号为虚函数表的结尾标识符，在不同编译器下值不同

#include<bits/stdc++.h>
usingnamespace std;
class Base
{
public:
    virtualvoid f()
    {
        cout << "Base::f" << endl;
    }
    virtualvoid g()
    {
        cout << "Base::g" << endl;
    }
    virtualvoid h()
    {
        cout << "Base::h" << endl;
    }

};
class Base_son:public Base
{
public:
    virtualvoid f1()
    {
        cout << "Base_son::f1" << endl;
    }
    virtualvoid g1()
    {
        cout << "Base_son::g1" << endl;
    }
    virtualvoid h1()
    {
        cout << "Base_son::h1" << endl;
    }

};


typedef void(*Fun)(void);
Base_son d;

Fun pFun = NULL;

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

    //通过虚函数表调用虚函数
    pFun = (Fun)*((int*)*(int*)(&d));   // Base::f()    pFun();
    pFun =(Fun)*((int*)*(int*)(&d)+1);  // Base::g()    pFun();
    pFun =(Fun)*((int*)*(int*)(&d)+2);  // Base::h()    pFun();

    pFun =(Fun)*((int*)*(int*)(&d)+3);  // Base_son::f1()    pFun();
    pFun =(Fun)*((int*)*(int*)(&d)+4);  // Base_son::g1()    pFun();
    pFun =(Fun)*((int*)*(int*)(&d)+5);  // Base_son::h1()    pFun();

    return0;
}

View Code

结果：

虚函数表地址：0x477008
虚函数表 — 第一个函数地址：0x473668
Base::f
Base::g
Base::h
Base_son::f1
Base_son::g1
Base_son::h1

View Code

2.单层继承有虚函数覆盖的情况

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

2）没有被覆盖的函数没有变化

#include<bits/stdc++.h>
usingnamespace std;
class Base
{
public:
    virtualvoid f()
    {
        cout << "Base::f" << endl;
    }
    virtualvoid g()
    {
        cout << "Base::g" << endl;
    }
    virtualvoid h()
    {
        cout << "Base::h" << endl;
    }

};
class Base_son:public Base
{
public:
    virtualvoid f()
    {
        cout << "Base_son::f" << endl;
    }
    virtualvoid g1()
    {
        cout << "Base_son::g1" << endl;
    }
    virtualvoid h1()
    {
        cout << "Base_son::h1" << endl;
    }

};


typedef void(*Fun)(void);
Base_son d;

Fun pFun = NULL;

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

    //通过虚函数表调用虚函数
    pFun = (Fun)*((int*)*(int*)(&d));   // Base_son::f()    pFun();
    pFun =(Fun)*((int*)*(int*)(&d)+1);  // Base::g()    pFun();
    pFun =(Fun)*((int*)*(int*)(&d)+2);  // Base::h()    pFun();

    pFun =(Fun)*((int*)*(int*)(&d)+3);  // Base_son::g1()    pFun();
    pFun =(Fun)*((int*)*(int*)(&d)+4);  // Base_son::h1()    pFun();

    return0;
}

View Code

结果：

虚函数表地址：0x477008
虚函数表 — 第一个函数地址：0x473650
Base_son::f
Base::g
Base::h
Base_son::g1
Base_son::h1

View Code

通过父类指针指向子类实例，子类覆盖父类方法，然后调用子类的方法，这样就实现了多态

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

3.多重继承无虚函数覆盖

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

2）子类的虚函数被放到第一个父类的虚函数表中

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

4.多重继承存在虚函数覆盖

1）父类虚函数表中被覆盖的虚函数全部被替换成了子类的覆盖虚函数

这样我们就通过父类指向子类从而访问子类的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()

View Code

使用虚函数表可以做一些违反c++语义的事情：

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

子类的虚函数X在父类中没有，所以子类的虚函数X没有覆盖父类的虚函数，但是如果我们通过父类的指针来访问子类自己的虚函数的编译器会报错

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

但是我们通过虚函数表可以做到这种违背C++语义的事情：使用父类指针访问子类自己的虚函数

2）访问父类non-public的虚函数

如果父类的虚函数是private或protected的，但是这些feipublic的父类虚函数同样会存在于虚函数表中，所以我们可以通过访问虚函数表访问到这些虚函数

附上多重继承有虚函数覆盖的样例代码：

#include <iostream>
usingnamespace std;
 
class Base1 {
public:
            virtualvoid f() { cout << "Base1::f" << endl; }
            virtualvoid g() { cout << "Base1::g" << endl; }
            virtualvoid h() { cout << "Base1::h" << endl; }
 
};
 
class Base2 {
public:
            virtualvoid f() { cout << "Base2::f" << endl; }
            virtualvoid g() { cout << "Base2::g" << endl; }
            virtualvoid h() { cout << "Base2::h" << endl; }
};
 
class Base3 {
public:
            virtualvoid f() { cout << "Base3::f" << endl; }
            virtualvoid g() { cout << "Base3::g" << endl; }
            virtualvoid h() { cout << "Base3::h" << endl; }
};
 
class Derive : public Base1, public Base2, public Base3 {
public:
            virtualvoid f() { cout << "Derive::f" << endl; }
            virtualvoid 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;
 
            return0;
}

View Code

关于虚函数和普通函数：

1.类中的虚函数是动态生成的，由虚函数表的指向进行访问，不为类的对象分配内存，没有虚函数表，就无法访问虚函数

2.类中的普通函数静态生成，不为类的对象分配内存也可访问

参考：左耳朵耗子：C++虚函数表解析

原文：https://www.cnblogs.com/yinbiao/p/10987640.html

内容总结

以上是互联网集市为您收集整理的C++中的虚函数以及虚函数表全部内容，希望文章能够帮你解决C++中的虚函数以及虚函数表所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1283836.html

来源：【匿名】

【上一篇】C++计算tensor指定坐标对应的falt数组内存偏移量【下一篇】c++有个库什么的吗?

更多 ►

【C++中的虚函数以及虚函数表】教程文章相关的互联网学习教程文章

一.虚函数的定义被virtual关键字修饰的成员函数，目的是为了实现多态ps：关于多态【接口和实现分离，父类指针指向子类的实例，然后通过父类指针调用子类的成员函数，这样可以让父类指针拥有多种形态，所以称之为多态】二.虚函数表该表为一个类的虚函数的地址表，用于解决继承和覆盖的问题1.拥有虚函数的类才有虚函数表2.虚函数表属于类，然后类的所有对象通过虚函数表指针共享类的虚函数表3.虚函数表的作用：当使用父类指针来操作子...

【C/C++学院】0816-引用包装器/仿函数/转义字符 R”()”/using别名/模板元编程比递归优化/智能指针/多线程/静态断言以及调试技能的要求 assert

引用包装器 std::ref(变量)#include<iostream>template<class T> void com(T arg)//模板函数，引用无效，引用包装器 {std::cout <<"com ="<< &arg << "\n";arg++; }void main() {int count = 10;int & rcount = count;com(count);std::cout << count << std::endl;//std::ref(变量) ，函数模板,引用包装器//com(std::ref(count));com(rcount);std::cout << "main=" << &rcount << "\n";std::cout << count << std::endl;std::cin...

c++ 用宏定义一个函数

#define MAX(a,b) ((a)>(b)?(a):(b))要点：变量都用括号括起来，防止出错，结尾不需要;。在实际编程中，不推荐把复杂的函数使用宏，不容易调试。多行用\#define CREATE_FUNC_TYPE(__TYPE__,__PARAM__) static __TYPE__* create(__PARAM__ para) { __TYPE__ *pRet = new(std::nothrow) __TYPE__(); if (pRet && pRet->init(para)) { pRet->autorelease(); return pRet; } else { delete pRet; pRet = NULL; return NULL; }...

C++中如何定义函数对象【代码】

尽管函数指针被广泛用于实现函数回调，但C++还提供了一个重要的实现回调函数的方法，那就是函数对象。函数对象（也称“算符”）是重载了“()”操作符的普通类对象。因此从语法上讲，函数对象与普通的函数行为类似。用函数对象代替函数指针有几个优点，首先，因为对象可以在内部修改而不用改动外部接口，因此设计更灵活，更富有弹性。函数对象也具备有存储先前调用结果的数据成员。在使用普通函数时需要将先前调用的结果存储在全程或...

C++中虚函数和多态【图】

1.C++中的虚函数C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技术，RTTI技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议。对C++ 了解的人都应该知道虚函数（Virt...

第9课函数重载分析（下）与C、C++相互调用【代码】【图】

重载与指针下面的函数指针将保存哪个函数的地址：在给p赋值的时候，我们使用了func，但是这里并没有指明参数，编译器是怎么知道这个func函数指的是第一个func函数呢？函数重载遇上指针：　　将重载函数名赋值给函数指针时　　　　1、根据重载规则挑选与函数指针参数列表一致的候选者　　　　2、严格匹配候选者的函数类型与函数指针的函数类型测试程序如下： 1 #include <stdio.h>2 #include <string.h>3 4int func(int x)5{6retu...

C++学习（三）入门篇——函数【代码】【图】

C++函数分两种：有返回值的和没返回值的1.有返回值的函数调用函数流程如图，sqrt(6.25)为函数调用，被调用的函数叫做被调用函数，包含函数调用的函数叫做调用函数。参数是发送给函数的信息，返回值是从函数中发送回去的值。在使用函数之前，C++编译器必须知道函数的参数类型和返回值类型。如果缺少，编译器将不知道如何解释返回值。C++程序应为程序中使用的每个函数提供原型sqrt()的函数原型...

cocos2d-x 通过JNI实现c/c++和Android的java层函数交互【图】

1.JNI JNI是Java Native Interface的缩写，中文为JAVA本地调用。从Java1.1开始，Java Native Interface(JNI)标准成为java平台的一部分，它允许Java代码和其他语言写的代码进行交互。JNI一开始是为了本地已编译语言，尤其是C和C++而设计的，但是它并不妨碍你使用其他语言，只要调用约定受支持就可以了。JNI实现流程：2.C++与java交互流程图：注：对于跨平台的 cocos2d-x 来说，除非必要，否则可不必深究其理，比如想要...

C++基类一定要写虚函数！！！

这是个提醒，算是吧！如果详细原理过程，可能会有一个大篇幅。但这里不想多加赘述，只说说它的破坏力！最近写了个图像处理框架，要做个基类来handle众多子类，写之前一直申称：要注意内存管理，写好析构函数。谁知最后还是偏偏忘记了将基类析构函数virtual化，结果在操控基类释放内存的一段程序中，发现基类释放了，但attach到他上面的子类对象keep住没能free。结果程序在集群上跑了几天，终于挂彩了。。。查了半天，终于发现base ...

c++构造函数具体解释

一、Default constructor1. 对于class X ，假设没有不论什么user-declaredconstructor，那么编译器生成的default constructor是没用的2. 编译器合成（扩张）的default constructor 是实用的4中情况 ①.带有default constructor的memberclass object Member class object 的Default constructor会在合成（扩张）的defaultconstructor调用。 ②.带有default constructor的baseclass 合成（扩张）的default const...

C/C++函数使用

1 memset将s所指向的某一块内存中的前n个字节的内容全部设置为ch指定的ASCII值，块的大小由第三个参数指定，这个函数通常为新申请的内存做初始化工作，其返回值为指向s的指针。函数介绍void *memset(void *s, int ch, size_t n);函数解释：将s中前n个字节（typedef unsigned int size_t ）用 ch 替换并返回 s 。memset：作用是在一段内存块中填充某个给定的值，它是对较大的结构体或数组进行清零操作的一种最快方法[1] 。 2 bz...

c++函数指针说明【代码】

下面随笔说明函数指针用法。函数指针的定义：　　定义形式：　　存储类型数据类型（*函数指针名)()　　含义：　　函数指针指向的是程序代码存储区函数指针的典型用途-----实现函数回调　　通过函数指针调用的函数　　　　例如将函数的指针作为参数传递给一个函数，使得在处理相似事件的时候可以灵活的使用不同的方法。　　调用者不关心谁是调用者　　　　需知道存在一个具有特定原型和限制条件的被调用函数。函数指针举例 1 #inc...

C++ string的size()和length()函数没有区别

C++标准库中的string中两者的源代码如下： size_type __CLR_OR_THIS_CALL length() const { // return length of sequence return (_Mysize); } size_type __CLR_OR_THIS_CALL size() const { // return length of sequence return (_Mysize); } 所以两者没有区别。 length是因为沿用C语言的习惯而保留下来的，string类最初只有length，引入...

【C++基础 08】virtual析构函数的作用

在面向对象语言中，接口的多种不同的实现方式即为多态。c++可以使用virtual来实现多态。如果不使用virtual的话，C++对成员函数使用静态联编，而使用virtual，并且在调用函数时是通过指针或引用调用，C++则对成员函数进行动态编联（也就是迟后绑定，运行的时候才确定调用哪个对象）。关于virtual的用法比较简单，不再复述，我们这次来看看virtual析构函数的作用。1.示例我们先来看一段代码：class A { public:~A(){cout<<"~A()";} }...

C++引用作为函数的参数【代码】

引用也可以作为一个函数的参数，如：我们定义交换两个数的函数swap，将函数的参数定义成引用的形式：1void swap(int &p1, int &p2) //此处函数的形参都是引用2{ 3int p; 4 p=p1; 5 p1=p2; 6 p2=p; 7 } 　　为了在程序中调用该函数，在相应的主调函数的调用点处直接以变量作为实参进行调用即可，而不需要对实参变量有任何的特殊要求。如上面定义的swap函数的主调函数可写为： int main() {int a,b;cin >> a >> b; ...

C++ - 技术教程分类

C++ 教程 C++ 简介 C++ 基本语法 C++ 注释 C++ 数据类型 C++ 变量类型 C++ 变量作用域 C++ 常量 C++ 修饰符类型 C++ 存储类 C++ 运算符 C++ 循环 C++ 判断 C++ 函数 C++ 数字 C++ 数组 C++ 字符串 C++ 指针 C++ 引用 C++ 日期 & 时间 C++ 基本的输入输出 C++ 数据结构 C++ 类 & 对象 C++ 继承 C++ 重载运算符和重载函数 C++ 多态 C++ 数据抽象 C++ 数据封装 C++ 接口（抽象类） C++ 文件和流 C++ 异常处理 C++ 动态内存 C++ 命名空间 C++ 模板 C++ 预处理器 C++ 信号处理 C++ 多线程 C++ Web 编程 C++ 标准库 C++ 有用的资源 C++ 实例 c++ 全部

C++ - 最热教程

C++通过共享内存实现进程间通信（windo...C++基于EasyX制作贪吃蛇游戏（一）文档 C++中的分治算法及常见题目汇总【C++】stringstream的str() 和 string...c++中内置函数qsort（快速排序）和bsea...VS2019 C++创建一个简单项目demo [C++]VS2015用动态链接(MD/MDd)方式编译...C/C++编程学习 - 第15周 ⑥ 药房管理万维考试系统检测不到VC++ 6.0环境解决...C/C++ QT自定义对话框与MID窗体

首页 / C++ / C++中的虚函数以及虚函数表

C++中的虚函数以及虚函数表

内容导读

内容图文

内容总结

内容备注

内容手机端

【C++中的虚函数以及虚函数表】教程文章相关的互联网学习教程文章