【C++】虚函数与虚函数表

已于 2022-05-21 21:04:56 修改
阅读量315 收藏 3
点赞数 1
分类专栏： C++ 文章标签： c++
于 2022-04-30 19:15:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46778443/article/details/124516444
版权

1. 虚函数表的结构

#include <iostream>
using namespace std;

typedef void (*Fun)(void);

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()
{
	Base base;
	Fun fun = nullptr;

	// &b返回Base *类型的指针
	cout << "该对象的地址：" << &base << endl;

	// (long*)(&base)将Base *类型的指针转换为long *类型的指针，转换后指针指向地址没变，但指向的对象的类型改变
	cout << "虚函数表指针：" << (long*)(&base) << endl;

	// *(long*)(&base)对long *类型的指针解引用，从该地址开始取出sizeof(long)个字节，赋值给一个long类型的对象
	cout << "虚函数表指针的地址：" << *(long*)(&base) << endl;

	// (long *)*(long *)(&b)相当于(long *)后接一个long值，返回long *，将这个long值作为该指针指向的地址值
	cout << "虚函数表指针：" << (long*)*(long*)(&base) << endl;

	// *(long *)*(long *)(&base)对long *类型的指针解引用，返回long值
	cout << "虚函数起始位置的地址：" << *(long*)*(long*)(&base) << endl;


	cout << "offset_to_top：" << *((long*)*(long*)(&base) - 2) << endl;
	cout << "typeinfo for Base：" << (long*)*((long*)*(long*)(&base) - 1) << endl;

	fun = (Fun) * ((long*)*(long*)(&base));
	cout << "虚函数表中第一个虚函数的地址：" << (long*)fun << endl;
	fun();

	fun = (Fun) * ((long*)*(long*)(&base) + 1);
	cout << "虚函数表中第二个虚函数的地址：" << (long*)fun << endl;
	fun();

	fun = (Fun) * ((long*)*(long*)(&base) + 2);
	cout << "虚函数表中第三个虚函数的地址：" << (long*)fun << endl;
	fun();

	system("pause");
	return 0;
}

详细版

简化版

2. 单继承 子类不重写父类虚函数

  • 虚函数按照其声明顺序放于表中。
  • 父类的虚函数在子类的虚函数前面。
#include <iostream>
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
{
public:
	virtual void f1() { cout << "Derived::f1()" << endl; }
	virtual void g1() { cout << "Derived::g1()" << endl; }
	virtual void h1() { cout << "Derived::h1()" << endl; }
};

简化版

3. 单继承 子类重写父类虚函数

  • 被子类重写的虚函数放到虚函数表中原来父类虚函数的位置。
  • 没有被覆盖的函数位置不变。
#include <iostream>
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
{
public:
	virtual void f() { cout << "Derived::f()" << endl; }
	virtual void g1() { cout << "Derived::g1()" << endl; }
	virtual void h1() { cout << "Derived::h1()" << endl; }
};

简化版

4. 多继承 子类不重写父类虚函数

  • 子类继承几个基类就有几个虚函数表指针。
  • 子类的特有的虚函数被放到了第一个父类的虚函数表中。
#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 Derived : public Base1, public Base2, public Base3
{
public:
	virtual void f1() { cout << "Derived::f1()" << endl; }
	virtual void g1() { cout << "Derived::g1()" << endl; }
};

在这里插入图片描述

5. 多继承 子类重写父类虚函数

#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 Derived : public Base1, public Base2, public Base3
{
public:
	virtual void f() { cout << "Derived::f()" << endl; }
	virtual void g1() { cout << "Derived::g1()" << endl; }
};

在这里插入图片描述

总结

如果一个类中有虚函数，那么该类就有一个虚函数表。虚函数表是属于类的，所有该类的实例化对象中都有一个虚函数表指针指向该类的虚函数表。一个类只能有一个虚函数表。在编译时，一个类的虚函数表就确定了，所以它放在了只读数据段中。
在这里插入图片描述

多层继承

多层继承的原则：子类根据在其上一层父类的虚函数表基础上进行修改。

#include <iostream>
using namespace std;

class ClassA
{
public:
	// 构造函数
	ClassA() :aData(0) { cout << "ClassA::ClassA()" << endl; }
	// 析构函数
	virtual ~ClassA() { cout << "ClassA::~ClassA()" << endl; }
	// 普通成员函数
	void func1() { cout << "ClassA::func1()" << endl; }
	void func2() { cout << "ClassA::func2()" << endl; }
	// 虚函数
	virtual void vfunc1() { cout << "ClassA::vfunc1()" << endl; }
	virtual void vfunc2() { cout << "ClassA::vfunc2()" << endl; }
private:
	int aData;
};

class ClassB : public ClassA
{
public:
	// 构造函数
	ClassB() :bData(0) { cout << "ClassB::ClassB()" << endl; }
	// 析构函数
	virtual ~ClassB() { cout << "ClassB::~ClassB()" << endl; }
	// 普通成员函数
	void func1() { cout << "ClassB::func1()" << endl; }
	// 虚函数
	virtual void vfunc1() { cout << "ClassB::vfunc1()" << endl; }
private:
	int bData;
};

class ClassC : public ClassB
{
public:
	// 构造函数
	ClassC() :cData(0) { cout << "ClassC::ClassC()" << endl; }
	// 析构函数
	virtual ~ClassC() { cout << "ClassC::~ClassC()" << endl; }
	// 普通成员函数
	void func2() { cout << "ClassC::func2()" << endl; }
	// 虚函数
	virtual void vfunc2() { cout << "ClassC::vfunc2()" << endl; }
private:
	int cData;
};


void test01()
{
	ClassA* a = new ClassB;
	a->func1();		// ClassA::func1()	隐藏子类同名函数
	a->func2();		// ClassA::func2()
	a->vfunc1();	// ClassB::vfunc1()	子类重写父类虚函数
	a->vfunc2();	// ClassA::vfunc2()

	delete a;
}

void test02()
{
	ClassA* a = new ClassC;
	a->func1();          // ClassA::func1()		隐藏子类ClassB同名函数           
	a->func2();          // ClassA::func2()		隐藏孙子类ClassC同名函数
	a->vfunc1();	     // ClassB::vfunc1()	子类ClassB重写父类ClassA虚函数
	a->vfunc2();	     // ClassC::vfunc2()	孙子类ClassC重写父类ClassA虚函数

	delete a;

	ClassB* b = new ClassC;
	b->func1();				// ClassB::func1()	隐藏父类ClassA同名函数          
	b->ClassA::func1();		// ClassA::func1()	
	b->func2();				// ClassA::func2()	
	b->vfunc1();			// ClassB::vfunc1()	子类ClassB重写父类ClassA虚函数
	b->vfunc2();			// ClassC::vfunc2()	孙子类ClassC重写父类ClassA虚函数

	delete b;
}

int main()
{
	test01();
	test02();
	system("pause");
	return 0;
}

注：C++对象模型中无普通成员函数指针，图中只为了方便区分。
对于函数test01：
在这里插入图片描述
对于函数test02：
注：C++对象模型中无普通成员函数指针，图中只为了方便区分。

多继承

在多继承情况下，有多少个基类就有多少个虚函数表指针，前提是基类要有虚函数。当有多个虚函数表时，虚函数表的结果是0代表没有下一个虚函数表。*号位置在不同操作系统中实现不同，代表有下一个虚函数表。

  • 子类虚函数会覆盖每一个父类的每一个同名虚函数。
  • 子类特有的虚函数，填入第一个父类的虚函数表中，且父类指针不能调用。
  • 父类特有的虚函数，则不覆盖，子类和该父类指针都能调用。
#include <iostream>
using namespace std;

class ClassA1
{
public:
	// 构造函数
	ClassA1() :a1Data(0) { cout << "ClassA1::ClassA1()" << endl; }
	// 析构函数
	virtual ~ClassA1() { cout << "ClassA1::~ClassA1()" << endl; }
	// 普通成员函数
	void func1() { cout << "ClassA1::func1()" << endl; }
	// 虚函数
	virtual void vfunc1() { cout << "ClassA1::vfunc1()" << endl; }
	virtual void vfunc2() { cout << "ClassA1::vfunc2()" << endl; }
private:
	int a1Data;
};

class ClassA2
{
public:
	// 构造函数
	ClassA2() :a2Data(0) { cout << "ClassA2::ClassA2()" << endl; }
	// 析构函数
	virtual ~ClassA2() { cout << "ClassA2::~ClassA2()" << endl; }
	// 普通成员函数
	void func1() { cout << "ClassA2::func1()" << endl; }
	// 虚函数
	virtual void vfunc1() { cout << "ClassA2::vfunc1()" << endl; }
	virtual void vfunc2() { cout << "ClassA2::vfunc2()" << endl; }
	virtual void vfunc4() { cout << "ClassA2::vfunc4()" << endl; }
private:
	int a2Data;
};

class ClassC : public ClassA1, public ClassA2
{
public:
	// 构造函数
	ClassC() :cData(0) { cout << "ClassC::ClassC()" << endl; }
	// 析构函数
	virtual ~ClassC() { cout << "ClassC::~ClassC()" << endl; }
	// 普通成员函数
	void func1() { cout << "ClassC::func1()" << endl; }
	// 虚函数
	virtual void vfunc1() { cout << "ClassC::vfunc1()" << endl; }
	virtual void vfunc2() { cout << "ClassC::vfunc2()" << endl; }
	virtual void vfunc3() { cout << "ClassC::vfunc3()" << endl; }
private:
	int cData;
};


void test01()
{
	ClassA1* a1 = new ClassC;
	a1->func1();               // ClassA1::func1()   隐藏子类同名函数
	a1->vfunc1();              // ClassC::vfunc1()   子类重写父类虚函数
	a1->vfunc2();              // ClassC::vfunc2()   子类重写父类虚函数
	//a1->vfunc3()	//  子类特有的虚函数，父类指针不能调用

	delete a1;

	ClassA2* a2 = new ClassC;
	a2->func1();               // ClassA2::func1()   隐藏子类同名函数
	a2->vfunc1();              // ClassC::vfunc1()   子类重写父类虚函数
	a2->vfunc2();              // ClassC::vfunc2()   子类重写父类虚函数
	a2->vfunc4();              // ClassA2::vfunc4()  未被子类重写的父类虚函数

	delete a2;

	ClassC* c = new ClassC;
	c->func1();				// ClassC::func1()	隐藏父类同名函数
	c->ClassA1::func1();	// ClassA1::func1()
	c->ClassA2::func1();	// ClassA2::func1()

	c->vfunc1();			// ClassC::vfunc1()
	c->vfunc2();            // ClassC::vfunc2()
	c->vfunc3();            // ClassC::vfunc3()
	c->vfunc4();            // ClassA2::func4()	父类特有的虚函数，子类也可以调用

	delete c;
}

int main()
{
	test01();
	system("pause");
	return 0;
}

注：C++对象模型中无普通成员函数指针，图中只为了方便区分。
注：C++对象模型中无普通成员函数指针，图中只为了方便区分。

参考：https://blog.csdn.net/weixin_43798887/article/details/118196343
参考：https://blog.csdn.net/haoel/article/details/1948051
参考：https://blog.csdn.net/qq_36359022/article/details/81870219

敢飞就有天空
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
虚函数表
迷雾江湖 的博客
12-15 620
一、虚函数的工作原理（虚函数表）        通常我们在类中编写了虚方法后，编译器是怎么来处理呢？        编译器处理虚函数的方法是：给每个对象加一个隐藏成员。这个隐藏成员中保存了一个指向函数地址数组的指针。这个数组称为虚函数表vtbl（virtual function table）。这个指针就叫虚表指针！        （1）、虚函数表存储什么呢？    
C++虚函数表实例分析
01-21
在对象中，有一个指针指向一张虚函数表，里面按照次序存放了每一个虚函数，当子类继承的时候，即到虚函数表的指定位置去修改函数地址。当我们通过父类指针来操作一个子类的时候，调用虚函数，都是通过虚函数表+固定...
c++中的虚函数及虚函数表
sinat_38606329的博客
07-04 904
一、虚函数的定义 有关键字virtual修饰的成员函数，为了实现多态。 二、虚函数表 1.虚函数表用来存放虚函数的地址，也称虚表。 2.一个含有虚函数的类中至少有一个虚表。 3.虚表指针：二级指针，虚函数指针的指针，存放在对象模型头部，32位系统中占4个字节，在64位系统中占8个字节。虚表指针中存放着虚表的首地址。可以通过对象实例化的地址得到虚函数表的地址。 4.虚表与虚表指针的关系如下： 三、...
c++虚函数有几个虚表
jiuzhouhi的专栏
03-07 4777
怕自己忘记了，所以复制一下，尊重他人版权，http://blog.csdn.net/haoel/article/details/1948051/ 前言   C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了
深度探索c++对象模型-05-虚函数表分析
FairLikeSnow的博客
07-11 636
总结： 1.一个类只有包含虚函数才会存在虚函数表，同属于一个类的对象共享虚函数表。但是有各自的VPTR指针。当然各自的VPTR所只指向的地址（虚函数表地址）相同。 2.分类中有虚函数，则子类一定有虚函数。 换句话：父类中有虚函数表，则子类中肯定有虚函数表。 3.不管是父类还是子类，都只有一个虚函数表，不能认为子类中有一个虚函数表、父类中有一个虚函数表，就认为子类有两个虚函数表，这是错误的。 4.如果子类中完全没有新的虚函数，则我们可以认为子的虚函数表和父类的虚函数表内容相同，当仅仅是内同相同，这两个表在..
C++中的虚函数重载
rockly89的博客
02-19 1万+
在一次修改代码过程中踩的坑，下来研究了一下，发现C++中虚函数重载后会产生很多有意思的情况，在这里总结了一下。 C++中有重载（overload）和重写（override）以及重定义这几个概念，1 overload：指的是相同作用域中的两个函数的函数名相同，但参数列表的个数、顺序、类型不同。而override指的是子类中重新定义的父类的虚函数。 2 override：overload要求两
C++虚函数表解析
03-03
前言C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型...
C++虚函数及虚函数表解析
07-24
每个具有虚函数的类都有一个与之关联的虚函数表，其中包含了该类及其所有基类虚函数的地址。当通过指针调用虚函数时，编译器会查找该指针所指向对象的虚函数表，然后调用表中对应的函数地址。这个过程在运行时完成，...
C++虚函数及虚函数表简析
09-03
总之，C++的虚函数和虚函数表是实现多态性的重要工具，它们允许我们在不知道对象具体类型的情况下调用适当的方法，增强了代码的通用性和可扩展性。理解虚函数的原理和使用限制对于编写高效、可靠的C++代码至关重要。
c++虚函数与虚函数表
01-13
学习 C++ 的同志不知道有没有和我一样遇到过这样的困惑:C++中的虚函数到底怎么实现的？...讲C++语法的书没有义务告诉你C++产生的虚函数表是什么样的,这就是头痛的所在。 自已做试验是件很快乐的事，我很愿意这么做。
子类和父类虚函数表
qq_38261075的博客
05-08 2712
子类和父类不会公用一个虚函数表，每个类都会有一个虚函数表。 具体验证可参考：c++ 子类没有虚函数，但是父类有虚函数，子类会新建虚表吗？
[程序员面试]C++虚函数表详细解释及实例分析
leo115的专栏
10-01 9927
C++的虚函数(Virtual Function)是通过一张虚函数表(Virtual Table)来实现的。简称为V-Table。在这个表中，主要是一个类的虚函数的地址表，这张表解决了继承、覆盖(override)的问题，保证其能真实的反应实际的函数。这样，在有虚函数的类的实例中这张表被分配在了这个实例的内存中，所以当我们用父类的指针操作一个子类的时候，这张虚函数表就显得尤为重要了，他就像一个地图
C++虚函数表(vtable)和虚函数指针(vfptr)
一首小夜曲
01-23 7050
编译器会构建一张虚表（ vtable )，每一个类都有自己独特的虚表。同时，在这个继承链上，编译器会为基类插入一个隐式的指针（一般是对象的首地址），指向虚表，称为__vptr。然后，子类继承父类时，会获得继承下来的__vptr，再根据自己的类的情况兼容（修改虚函数表里的值、发生偏移等。于是，当我们构建具体的类时，若是基类类型，__vptr就会指向父类的vtable，若是子类类型，__vptr就会指
C++ 虚函数表解析---陈皓改进版
a3192048的博客
08-29 3562
修正了一些原文中的错误。 前言 C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技术，RTTI技术(Run-Time Type Identification)，虚函数技术，要...
C++ 虚函数表 vfptr
热门推荐
好记性不如烂笔头
09-25 2万+
前言大家都应该知道C++的精髓是虚函数吧? 虚函数带来的好处就是: 可以定义一个基类的指针, 其指向一个继承类, 当通过基类的指针去调用函数时, 可以在运行时决定该调用基类的函数还是继承类的函数. 虚函数是实现多态(动态绑定)/接口函数的基础. 可以说: 没有虚函数, C++将变得一无是处!既然是C++的精髓, 那么我们有必要了解一下她的实现方式吗? 有必要! 既然C++是从C语言的基础上发展而来的
C++虚函数表详解
amoscykl的博客
01-05 1万+
C++的虚函数(Virtual Function)是通过一张虚函数表(Virtual Table)来实现的。简称为V-Table。在这个表中，主要是一个类的虚函数的地址表，这张表解决了继承、覆盖(override)的问题，保证其能真实的反应实际的函数。这样，在有虚函数的类的实例中这张表被分配在了这个实例的内存中，所以当我们用父类的指针操作一个子类的时候，这张虚函数表就显得尤为重要了，他就像一个地...
虚函数和虚函数表
一面之媛
08-12 979
多态是由虚函数实现的，而虚函数主要是通过虚函数表（V-Table）来实现的。 如果一个类中包含虚函数（virtual修饰的函数），那么这个类就会包含一张虚函数表，虚函数表存储的每一项是一个虚函数的地址。如下图： 这个类的每一个对象都会包含一个虚指针（虚指针存在于对象实例地址的最前面，保证虚函数表有最高的性能），这个虚指针指向虚函数表。 注：对象不包含虚函数表，只有虚指针，类才包含虚函数表，派生类会生成一个兼容基类的虚函数表。 原始基类的虚函数表 　　下图是原始基类的对象，可以看到虚指针在地址的最
深入理解C++多态与虚函数表
虚函数表（Virtual Table，简称VTBL）是C++实现动态绑定（也称为运行时多态）的关键机制。每个包含虚函数的类都有一个虚函数表，其中存储了类中虚函数的地址。当通过基类指针调用虚函数时，编译器会在运行时查找对应...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值