c++虚函数表

最新推荐文章于 2025-09-12 18:45:12 发布
最新推荐文章于 2025-09-12 18:45:12 发布
阅读量53 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： c/c++
原文链接：http://www.cnblogs.com/ruan875417/p/4558281.html

C++中的虚函数(Virtual Function)的实现通过一张虚函数表来实现的，简称为V-Table。在这个表中，主要是一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其真实反应实际的函数。这样，在有虚函数的类的实例中分配了指向这个表的指针的内存，所以，当用父类的指针来操作一个子类的时候，这张虚函数表就显得尤为重要了，它就像一个地图一样，指明了实际所应该调用的函数。

编译器应该是保证虚函数表的指针存在于对象实例中最前面的位置（这是为了保证取到虚函数表的有最高的性能——如果有多层继承或是多重继承的情况下）。这意味着可以通过对象实例的地址得到这张虚函数表，然后就可以遍历其中函数指针，并调用相应的函数。

下面讨论虚函数表的各种情况，我用的是VS 2013，因此都是在VS 2013编译器下讨论各种情况的：

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

1、例子

#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; }
private:
	virtual void i() { cout << "Base::i()" << endl; }
};
class Derive:public Base{
public:
	virtual void f1(){ cout << "Derive::f1()" << endl; }
	virtual void g1(){ cout << "Derive::g1()" << endl; }
	virtual void h1(){ cout << "Derive::h1()" << endl; }
};

int main(){
    typedef void(*pFun)(); //定义一个函数指针，参数列表空，返回值void
	Base base;
	int** pVtab = (int**)&base;
	for (int i = 0; pVtab[0][i] != NULL; ++i){
		cout << "虚函数表存放第"<<i+1<<"个函数地址的地址：" << pVtab[0]+i << endl; //pVtab[0]+i等同于(int*)*(int*)(&base) + i，参考文章那边有错误 
		cout << "虚函数表第" << i + 1 << "个函数地址：" << (int*)pVtab[0][i] << endl;//(int*)pVtab[0][i]等同于(int*)*((int*)*(int*)(&base) + 1)
		((pFun)pVtab[0][i])();
	}
	cout << "------------------------------------------------------------------" << endl;
	Derive derive;
	pVtab = (int**)&derive;
	for (int i = 0; pVtab[0][i] != NULL; ++i){
		cout << "虚函数表存放第" << i + 1 << "个函数地址的地址：" << pVtab[0] + i << endl; //pVtab[0]+i等同于(int*)*(int*)(&derive) + i
		cout << "虚函数表第" << i + 1 << "个函数地址：" << (int*)pVtab[0][i] << endl; //(int*)pVtab[0][i]等同于(int*)*((int*)*(int*)(&derive) + 1)
		((pFun)pVtab[0][i])();
	}

	system("pause");
	return 0; 
}

2、运行结果：


3、类继承关系


4、基类虚表指针及虚表布局：


5、继承类虚表指针及虚表布局：


6、说明

1）VS 2013中虚表指针放在对象的起始位置。

2）在同一个访问区段中虚函数按照其声明顺序放于表中，但各个访问区段的先后顺序并不一定。

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

4）基类的虚函数i()是private的，但用虚表指针能访问到。

二、单继承（有虚函数覆盖）

1、例子

#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 Derive :public Base{
public:
	virtual void f(){ cout << "Derive::f()" << endl; }
	virtual void g1(){ cout << "Derive::g1()" << endl; }
	virtual void h1(){ cout << "Derive::h1()" << endl; }
};

int main(){
	typedef void(*pFun)(); //定义一个函数指针，参数列表空，返回值void
	Base base;
	int** pVtab = (int**)&base;
	for (int i = 0; pVtab[0][i] != NULL; ++i){
		cout << "虚函数表存放第" << i + 1 << "个函数地址的地址：" << pVtab[0] + i << endl; //pVtab[0]+i等同于(int*)*(int*)(&base) + i，参考文章那边有错误 
		cout << "虚函数表第" << i + 1 << "个函数地址：" << (int*)pVtab[0][i] << endl;//(int*)pVtab[0][i]等同于(int*)*((int*)*(int*)(&base) + 1)
		((pFun)pVtab[0][i])();
	}
	cout << "------------------------------------------------------------------" << endl;
	Derive derive;
	pVtab = (int**)&derive;
	for (int i = 0; pVtab[0][i] != NULL; ++i){
		cout << "虚函数表存放第" << i + 1 << "个函数地址的地址：" << pVtab[0] + i << endl; //pVtab[0]+i等同于(int*)*(int*)(&derive) + i
		cout << "虚函数表第" << i + 1 << "个函数地址：" << (int*)pVtab[0][i] << endl; //(int*)pVtab[0][i]等同于(int*)*((int*)*(int*)(&derive) + 1)
		((pFun)pVtab[0][i])();
	}

	system("pause");
	return 0;
}
2、 运行结果：


3、类继承关系：


4、基类虚表指针及虚表布局：


5、继承类虚表指针及虚表布局：


6、说明

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

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

1、 例子 

#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 f1(){ cout << "Derive::f1()" << endl; }
	virtual void g1(){ cout << "Derive::g1()" << endl; }
	virtual void h1(){ cout << "Derive::h1()" << endl; }
};

int main(){
	typedef void(*pFun)(); //定义一个函数指针，参数列表空，返回值void
	
	Derive derive;
	int** pVtab = (int**)&derive;
	for (int s = 0; s < 3; ++s){
		for (int i = 0; pVtab[s][i] != NULL; ++i){
			cout << "第" << s + 1 << "个虚函数表存放第" << i + 1 << "个函数地址的地址：" << pVtab[s] + i << endl; //pVtab[s]+i等同于 (int*)*((int*)(&derive) + s) + i
			cout << "第" << s + 1 << "个虚函数表存放第" << i + 1 << "个函数地址：" << (int*)pVtab[s][i] << endl; //(int*)pVtab[s][i]等同于(int*)*((int*)*((int*)(&derive) + s) + i)
			((pFun)pVtab[s][i])();
		}
		cout << "------------------------------------------------------------------" << endl;
	}
	
	system("pause");
	return 0;
}
2、 运行结果：


3、类继承关系：


4、继承类虚表指针及虚表布局：


5、说明

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

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

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

1、 例子： 

#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 g2() { cout << "Base2::g2()" << 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 g2(){ cout << "Derive::g2()" << endl; }
	virtual void h1(){ cout << "Derive::h1()" << endl; }
};

int main(){
	typedef void(*pFun)(); //定义一个函数指针，参数列表空，返回值void

	Derive derive;
	int** pVtab = (int**)&derive;
	for (int s = 0; s < 3; ++s){
		for (int i = 0; pVtab[s][i] != NULL; ++i){
			cout << "第" << s + 1 << "个虚函数表存放第" << i + 1 << "个函数地址的地址：" << pVtab[s] + i << endl; //pVtab[s]+i等同于 (int*)*((int*)(&derive) + s) + i
			cout << "第" << s + 1 << "个虚函数表存放第" << i + 1 << "个函数地址：" << (int*)pVtab[s][i] << endl; //(int*)pVtab[s][i]等同于(int*)*((int*)*((int*)(&derive) + s) + i)
			((pFun)pVtab[s][i])();
		}
		cout << "------------------------------------------------------------------" << endl;
	}

	Base1* base1 = &derive; 
	base1->f();//Derive::f()

	Base2* base2 = &derive;
	base2->g2();//derive::g2()

	Base3* base3 = &derive;
	base3->h();//Base3::h()

	system("pause");
	return 0;
}
2、 运行结果：


3、类继承关系：


4、继承类虚表指针及虚表布局：


5、说明

1）三个父类虚函数表中的f()的位置被替换成了子类的函数指针。

2）Base2中的虚函数g2()的位置被替换成了子类的函数指针


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

转载于:https://www.cnblogs.com/ruan875417/p/4558281.html

C++ 多态与虚函数表（一）—— 单继承
行走
08-16 1729
一、前言 个人笔记，不保证严谨和正确☺，如有错误还望指出！ 《C++ 多态与虚函数表（一）—— 单继承》 《C++ 多态与虚函数表（二）—— 多继承》 《C++ 多态与虚函数表（三）—— 重复继承》 《C++ 多态与虚函数表（四）—— 虚继承》 《C++ 多态与虚函数表（五）拓展—— 对象大小》 二、取地址 class Base { public: long long value; virtual f(); }; typedef void(*ptrType)(vo.
C++ 对象内存模型
一只老风铃
09-12 1633
继承，封装，多态是面向对象的三大特性之一，以类为例，类分为数据成员和函数 而函数分为static、非static、virtual函数三大类函数，那么一般的C++对象其内存模型是如何。 类中存在部分： 成员变量 静态成员变量 成员函数 静态成员函数 构造函数 析构函数 虚函数 虚析构函数 纯虚函数 通常而言对于一个对象，其在内存中的模型不包含函数，只包含成员，而函数单独存放，所有对象通过地址进行调用。对象在内存模型及其占用大小受几方面因素影响： 成员变量 虚表指针 虚基类表指.
C++虚函数表
weixin_44965579的博客
10-12 1081
C++虚函数表
C++ 虚函数表
Cdreamfly的博客
10-17 6596
public ://和上上个类不同的是多了一个自身定义的虚函数. 和上个类不同的是没有基类虚函数的覆盖. virtual void derive1_fun1() {} };为嘛呢？现在继承类明明定义了自身的虚函数，但不见了？类对象的大小，以及成员偏移情况居然没有变化！要注意：我为什么使用指针的方式调用？说明一下：因为如果不使用指针调用，虚函数调用是不会发生动态绑定的哦！你若直接 d1.derive1_fun1()；
C++虚函数表详解
weixin_40332490的博客
02-22 888
每个使用虚函数的类（或者从使用虚函数的类派生）都有自己的虚函数表虚函数表是编译器在编译时设置的静态数组虚函数表中包含可由类的对象调用的每个虚函数的函数指针，指向该类可访问的虚函数。编译器还会添加一个隐藏指向虚函数表的指针，称之为虚表指针vptr。虚表指针vptr在创建类实例时自动生成，以便指向该类的虚拟表虚表指针vptr是一个真正的指针，每个类对象的都会分配一个。这也意味着vptr会由派生类继承结论：构造函数不能，析构函数可以，且某些情况下析构函数是必须声明为虚函数。原因：① 析构函数。
C++虚函数表机制详解
m0_45371381的博客
03-02 912
在C++中，虚函数表（vtable）是实现动态多态的核心机制。核心机制：虚函数表通过存储虚函数地址和vptr实现动态绑定。多态实现：允许基类指针调用派生类函数。编译器依赖：具体实现（如vptr位置、vtable结构）因编译器而异。理解虚函数表有助于深入掌握C++多态原理及对象内存模型，但对实际开发而言，应遵循面向对象设计原则，而非直接操作虚函数表。
C++ 虚函数表（vtable）
qq_40844444的博客
01-22 799
在 C++ 中，虚函数表是实现多态性的核心机制。当一个类包含虚函数时，编译器会为该类创建一个虚函数表。这个表存储了该类及其基类中所有虚函数的函数指针。对于每个包含虚函数的对象，对象的内存布局的最开始部分包含一个指向虚函数表的指针（通常称为 ）。首先，我们创建一个基类 和一个派生类 来说明虚函数表的工作原理： 代码解释 类定义：打印虚函数表的函数 ：在 函数中：当运行上述代码时，可能会看到如下输出： 内存布局和虚函数表指针 对于 类的对象，其内存布局可能如下： 对于 类的对象，其内存布局如下：
【C++】C++ 虚函数表（Virtual Function Table，vtable）详解
weixin_43510208的博客
06-04 1805
虚函数表是实现运行时多态（动态绑定）的核心机制。它本质上是一个隐藏的函数指针数组，由编译器自动生成和管理
C++虚函数表、虚继承，类的大小
Yimi-依米 的博客
04-02 1756
C++虚函数表所占的大小？有虚函数的对象比没有虚函数的对象所占字节大小有区别吗？虚继承、虚函数继承中具体类大小的计算；构造函数里调用虚函数是实引用还是虚引用？
C++虚函数表实例分析
01-21
在对象中，有一个指针指向一张虚函数表，里面按照次序存放了每一个虚函数，当子类继承的时候，即到虚函数表的指定位置去修改函数地址。当我们通过父类指针来操作一个子类的时候，调用虚函数，都是通过虚函数表+固定...
C++虚函数表、地址详解（x86/x64）
yuemouren的博客
08-08 1377
本文在上述博文的基础上，补充了x64下的验证代码。虚函数大家都知道是基本用于实现多态的，当父指向子类对象的时候，如何确定调用的函数是父类里的还是子类里面的，这就要用到虚函数表。下面一点点表诉什么是虚函数表，和虚函数表的特点。如有说错的地方，欢迎指正：1.编译器会为每个创建一个虚函数表如有类中没有虚函数，那么这个虚函数表就不存在，而不是表中无数据。同时，有虚函数的类都会有自己的虚函数表，虚函数表会被一个类的所有对象所拥有。
【C++】list 容器操作
C语言、数据结构、单片机、嵌入式实时操作系统、C++ 学习路径记录
09-09 461
文章摘要：本文介绍了C++中list容器的特性与应用。list作为vector的补充，解决了vector在头部/中部插入删除效率低（O(N)）和扩容代价大的问题，具有O(1)时间复杂度的插入删除优势，但牺牲了随机访问能力。文章详细讲解了list的四种迭代器（正向/反向/const/双向）、常用操作（头尾插删、任意位置操作）、排序方法（不推荐使用），以及迭代器失效问题和解决方案。最后通过对比vector和list的迭代器实现原理，解释了list采用节点指针封装实现迭代器自增操作的机制。
C++标准库：字符串流类
weixin_50859396的博客
09-09 305
摘要：C++标准库中的字符串流类（<sstream>）提供了字符串与其他数据类型间的灵活转换功能，包含三类核心流：istringstream（输入流）、ostringstream（输出流）和stringstream（双向流）。这些类支持数据的格式化拼接、解析及类型转换，常用于日志生成、配置解析等场景。使用时需注意状态清除（clear()）和内容清空（str("")），并可通过iomanip实现格式化控制。字符串流是内存I/O操作的核心工具，兼具高效与灵活性。
C++ 学习与 CLion 使用：（十三）分别提供了 CLion 中使用 cout 和 cin 中文乱码的问题
qq_51409113的博客
09-10 539
分别提供了 CLion 中使用 cout 和 cin 中文乱码的问题
C语言深度入门系列：第八篇 - 结构体、联合体与枚举：程序世界的复合数据类型大师
而世之奇伟、瑰怪，非常之观，常在于险远，而人之所罕至焉，故非有志者不能至也！
09-10 775
复合数据类型是C语言程序设计的高级特性，掌握了它们，您就能够构建出复杂而高效的数据结构，为实现大型程序打下坚实基础。这些概念在后续学习数据结构、算法以及系统编程时将发挥重要作用。
设计模式(C++)详解—抽象工厂模式 (Abstract Factory)(2)
最新发布
weixin_42108533的博客
09-12 611
抽象工厂模式详解 抽象工厂模式是一种创建型设计模式，用于创建一系列相关或依赖对象的家族。它解决了在不指定具体类的情况下创建相互关联的产品对象的问题。 核心特点： 提供"工厂的工厂"概念，能创建整套相互关联的产品 确保创建的产品能协同工作（如苹果生态设备） 客户端代码只依赖抽象接口，与具体实现解耦 适用场景： 跨平台UI组件开发 数据库访问层 游戏开发中的不同风格角色/道具 主题系统切换 优势： 产品兼容性保证 易于切换整套产品族 符合开闭原则（新增产品族无需修改代码） 扩展性特点： 纵向
C++设计模式，高级开发，算法原理实战，系统设计与实战（视频教程）
闲余知道
09-10 1353
C++设计模式，高级开发，算法原理实战，系统设计与实战（视频教程）
西嘎嘎学习 - C++ 继承 - Day 10
zxhssl的博客
09-11 893
本文介绍了面向对象编程中的继承机制。继承允许派生类复用基类的属性和方法，支持单继承和多继承两种形式。文章详细说明了基类与派生类的关系、访问控制（public/protected/private）、三种继承方式（public/protected/private）及其对成员可见性的影响，并通过C++代码示例演示了继承的实现。此外，还探讨了构造函数/析构函数的调用顺序、多继承的菱形问题及虚继承的解决方案。继承机制能有效提高代码复用性和开发效率，是面向对象编程的重要特性。
深入理解C++虚函数表机制
"C++虚函数表解析" C++中的虚函数是实现多态性的重要机制，它允许通过基类指针调用派生类的重写成员函数，从而实现动态绑定。多态性是泛型编程的一种形式，旨在用不变的代码处理可变的数据或算法。C++的多态实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值