C++基础——虚指针（vptr）与虚基表（vtable）

最新推荐文章于 2024-03-14 08:16:10 发布
最新推荐文章于 2024-03-14 08:16:10 发布
阅读量3.5k 收藏 23
点赞数 14
分类专栏： C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25065595/article/details/107372446
版权

vptr与vtable

带有虚函数的类，通过该类所隐含的虚函数表来实现多态机制（用来确定调用基类的成员函数，还是调用派生类的该同名函数），该类的每个对象均具有一个指向本类虚函数表的指针，这一点并非C++标准所要求的，而是编译器所采用的“内部方式”。不同平台、不同编译器厂商所生成的虚表指针在内存中的布局是不同的，有些将虚表指针置于对象内存中的开头处，有些则置于结尾处。如果涉及多重继承和虚继承，情况还将更加复杂。基于此，永远不要做任何假设，永远不要使用memcpy()之类的函数复制对象，而应该使用初始化（构造和拷构）或赋值的方式来复制对象。

虚函数

手动操作vptr 来访问vtable中的虚函数，如以下测试程序：

#include <iostream>
#include <memory>
using namespace std;


typedef void (*func)(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;
	
	//获取vptr的地址，运行在visual studio  x86环境下，所以将指针按int*大小处理
    //另外基于C++的编译器应该是保证虚函数表的指针存在于对象实例中最前面的位置
	int* vPtr = (int*)(&base);
	//获取vTable 首个函数的地址
	func vTable_f = (func)*(int*)(*vPtr);
	//获取vTable 第二个函数的地址
	func vTable_g = (func)*((int*)(*vPtr) + 1);//加1 ，按步进计算
	func vTable_h = (func)*((int*)(*vPtr) + 2);//同上

	vTable_f();
	vTable_g();
	vTable_h();

	return 0;
}

如下图中所示，在虚函数表的最后多加了一个结点，这是虚函数表的结束结点，就像字符串的结束符“/0”一样，其标志了虚函数表的结束。这个结束标志的值在不同的编译器下是不同的。在WinXP+VS2003下，这个值是NULL。而在Ubuntu 7.10 + Linux 2.6.22 + GCC 4.1.3下，这个值是如果1，表示还有下一个虚函数表，如果值是0，表示是最后一个虚函数表。

一般继承，无虚函数的覆盖

我们将通过实例来验证子类实例虚函数表中虚函数的组成方式（父类的虚函数在子类的虚函数前面）：

#include <iostream>
#include <memory>
using namespace std;


typedef void (*func)(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; }
};

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; }
};

void base_virtual_ptr_test() 
{
	Base base;

	//获取vptr的地址，运行在visual studio  x86环境下，所以将指针按int*大小处理
	int* vPtr = (int*)(&base);
	//获取vTable 首个函数的地址
	func vTable_f = (func)*(int*)(*vPtr);
	//获取vTable 第二个函数的地址
	func vTable_g = (func)*((int*)(*vPtr) + 1);//加1 ，按步进计算
	func vTable_h = (func)*((int*)(*vPtr) + 2);//同上

	vTable_f();
	vTable_g();
	vTable_h();
}

void derive_virtual_ptr_test()
{
	Derive d;

	//获取vptr的地址，运行在visual studio  x86环境下，所以将指针按int*大小处理
	int* vPtr = (int*)(&d);
	//获取vTable 首个函数的地址
	func vTable_f = (func)*(int*)(*vPtr);
	//获取vTable 第二个函数的地址
	func vTable_g = (func)*((int*)(*vPtr) + 1);//加1 ，按步进计算
	func vTable_h = (func)*((int*)(*vPtr) + 2);//同上
	func vTable_f1 = (func)*((int*)(*vPtr) + 3);//同上
	func vTable_g1 = (func)*((int*)(*vPtr) + 4);//同上
	func vTable_h1 = (func)*((int*)(*vPtr) + 5);//同上

	vTable_f();
	vTable_g();
	vTable_h();

	vTable_f1();
	vTable_g1();
	vTable_h1();
}

int main() 
{
	derive_virtual_ptr_test();

	return 0;
}

对于实例：Derive d; 的虚函数表如下：

有虚函数覆盖的继承

#include <iostream>
#include <memory>
using namespace std;


typedef void (*func)(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; }
};

class Derive1 :public Base
{
public:
	virtual void f() { cout << "Derive1::f" << endl; }
	virtual void g1() { cout << "Derive1::g1" << endl; }
	virtual void h1() { cout << "Derive1::h1" << endl; }
};


void derive1_virtual_ptr_test()
{
	Derive1 d;

	//获取vptr的地址，运行在visual studio  x86环境下，所以将指针按int*大小处理
	int* vPtr = (int*)(&d);
	//获取vTable 首个函数的地址
	func vTable_f = (func)*(int*)(*vPtr);
	//获取vTable 第二个函数的地址
	func vTable_g = (func)*((int*)(*vPtr) + 1);//加1 ，按步进计算
	func vTable_h = (func)*((int*)(*vPtr) + 2);//同上
	func vTable_f1 = (func)*((int*)(*vPtr) + 3);//同上
	func vTable_g1 = (func)*((int*)(*vPtr) + 4);//同上
	func vTable_h1 = (func)*((int*)(*vPtr) + 5);//同上

	vTable_f();
	vTable_g();
	vTable_h();

	vTable_f1();
	vTable_g1();
	vTable_h1();
}

int main() 
{
	derive1_virtual_ptr_test();

	return 0;
}

执行以上程序，输出结果如上所示，但程序执行到vTable_h1时会报错；根据以上输出，我们可以知晓子类的 f() 覆盖了Base基类的f（）虚函数，非继承覆盖的函数会按基类，然后子类的虚函数顺序放到vTable中，虚函数表的组成如下所示（和我们的输出是一致的）：

无虚函数覆盖的多重继承

#include <iostream>
#include <memory>
using namespace std;


typedef void (*func)(void);
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 Derive2 :public Base1,public Base2,public Base3
{
public:
	virtual void f1() { cout << "Derive::f1" << endl; }
	virtual void g1() { cout << "Derive::g1" << endl; }
};


void multi_derive2_virtual_ptr_test()
{
	Derive2 d;

	int* vPtr = (int*)(&d);
	//获取第一个vPtr指向的vTable 第四和第五个函数的地址
	func vTable_g1 = (func)*((int*)(*vPtr) + 3);//加3 ，按步进计算
	func vTable_h1 = (func)*((int*)(*vPtr) + 4);//同上

	vTable_g1();
	vTable_h1();

	//用于比较，我们再来获取Base3的函数指针
	int* vPtr_Base3 = ((int*)(&d) + 2);
	func vTable_Base3_f = (func)*(int*)(*vPtr_Base3);
	vTable_Base3_f();

}

int main() 
{
	multi_derive2_virtual_ptr_test();

	return 0;
}

通过Derive2 d的实例可以查看虚函数表如下（显示的并不完整，我们将通过代码来获取子类的虚函数）：

上述测试程序的结果如下：

通过测试输出结果，可以获得如下的继承关系以及虚函数表的形式，如下所示：

               

 

有虚函数覆盖的多重继承

#include <iostream>
#include <memory>
using namespace std;


typedef void (*func)(void);
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 Derive3 :public Base1, public Base2, public Base3
{
public:
	virtual void f() { cout << "Derive3::f1" << endl; }
	virtual void g1() { cout << "Derive3::g1" << endl; }
};

void multi_derive3_virtual_ptr_test()
{
	Derive3 d;

	//分别获取三个虚指针指向的三个虚基表的第一个函数地址
	int* vPtr = (int*)(&d);
	//第一个虚指针指向的虚基表第一个函数地址
	func vTable_Base1_f = (func)*((int*)(*vPtr));

	//第二个虚指针指向的虚基表第一个函数地址
	int* vPtr_Base2 = ((int*)(&d) + 1);
	func vTable_Base2_f = (func)*(int*)(*vPtr_Base2);
	//第三个虚指针指向的虚基表第一个函数地址
	int* vPtr_Base3 = ((int*)(&d) + 2);
	func vTable_Base3_f = (func)*(int*)(*vPtr_Base3);

	vTable_Base1_f();
	vTable_Base2_f();
	vTable_Base3_f();

}

通过实例对象来查看虚指针和所指向的虚函数表，可以看到Base1，Base2，Base3 的第一个虚函数都被子类的f()覆盖了(当然这里也是显示不完全的，子类的虚函数g1函数并没有显示出来，利用上个测试方式也是可以获取到的)：

测试程序的输出如下：

通过测试输出结果，可以获得如下的继承关系以及虚函数表的形式，如下所示：

           

 

以上参考：

&动感超人
关注
  • 14
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
关于vptr（虚指针）和vtbl（虚函数表）1
08-08
2．静态绑定与动态绑定在C中，对于不同的函数名采用静态绑定的方法，每个函数直接对应了一个地址，存储在相应的位置中。需要注意的是，new和delete操作应该是静
C++继承中的详解，虚基表的理解
w903414的博客
01-31 740
继承、虚基表
深入解析C++虚函数表（vtable）和虚指针（vptr）
最新发布
karl2000的专栏
03-14 1612
在C++中，虚函数表（vtable）和虚指针（vptr）是实现多态性的关键机制。
【C++】虚表和虚基表到底有哪些区别？
qq_40376612的博客
05-24 1401
虚表和虚基表在同时存在时的对象模型
虚函数表及虚函数表指针（看似简单，深入部分也不是很懂）
fengdijiang的专栏
06-13 2755
class Base{ virtual void print(){} }; class Base2{ virtual void dprint(){} }; class CBase: public Base, public Base2{ }; //g++ align.cpp -fdump-class-hierarchy -------------------------------------linux 64位系统--------------------------------------...
深入解析C++中的虚函数与多态
01-21
1.C++中的虚函数C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技术，RTTI技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议。 对C++ 了解的人都应该知道虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）和一个指向虚函数表的指针（vptr）来实现的。虚函数表，简称为vtbl，虚函数表表对实现多态起着至关重要
虚基表和虚表
HXiaoFan的博客
07-21 3531
1 虚基表 （1）菱形继承 在菱形继承中，类D有两个_a，一个是B类从A类继承而来的，一个是C类从A类继承而来的 在对D类赋值时必须指定是对那个_a赋值，否则会出现数据不明确的问题。 所以菱形继承会造成数据的二义性。 //菱形继承 class A { public: int _a; }; class B:public A { public: int _b; }...
（一图胜千言）虚函数实现机制（Vptr, Vtbl）
L_Y_Fei的博客
03-23 1865
1.讲解C++中虚函数的实现机制，主要是Vptr和Vtbl的讲解，有了虚函数才可以拥有像多态这种强大的功能。
虚函数表（vtable）
青衫客36的博客
08-06 1667
虚函数表是一个存放指向虚函数的指针数组。每一个有虚函数的类（或者从有虚函数的类继承而来的类）都有一个相关联的虚函数表。
继承（六）—— 菱形继承的问题以及解决方案（初识虚基表）
challenglistic的博客
11-06 5724
了解菱形继承的问题以及解决方案
C++——虚函数表和虚基表
m0_72165281的博客
01-27 931
虚基表和虚函数
C++中虚函数的实现机制
10-27
介绍了C++编程语言中的虚函数及其在进行面向对象程序设计中重要性，并且详细阐述了它在编译器底层虚函数的实现机制．它通过一个vptr和vtable在运行时进行动态绑定，从而能够根据对象类型的不同调用不同的 虚函数；并通过实例测试验证了上述机制.
路基表 碎石垫层检查表.doc
09-11
路基表 碎石垫层检查表.doc
路基表 片块石垫层检查表.doc
09-11
路基表 片块石垫层检查表.doc
路基表3 公路工程砂垫层质量检查表.doc
09-11
路基表3 公路工程砂垫层质量检查表.doc
路基表2 公路工程石方路基质量检查表.doc
09-11
路基表2 公路工程石方路基质量检查表.doc
C++ 虚继承对基类构造函数调用顺序的影响
01-20
继承作为面向对象编程的一种基本特征，其使用频率... 　假设derived 虚继承自base类，那么derivd与base是一种“has a”的关系，即derived类有一个指向base类的vptr。（貌似有些牵强！某些编译器确实如此） 　因此虚
C++基础——智能指针 shared_ptr 和 weak_ptr 的使用
qq_25065595的博客
07-15 5200
shared_ptr shared_ptr 是一个标准的共享所有权的智能指针，允许多个指针指向同一个对象，定义在 memory 文件中，命名空间为 std。shared_ptr最初实现于Boost库中，后由 C++11 引入到 C++ STL。shared_ptr 利用引用计数的方式实现了对所管理的对象的所有权的分享，即允许多个 shared_ptr 共同管理同一个对象。 shared_ptr 的基本用法 #include <iostream> #include <memory
c++虚函数表指针放在对象的哪里
05-22
在C++中，每个包含虚函数的类都会生成一个虚函数表（vtable），这个表是一个存储了类中虚函数地址的数组。对于一个类的对象，它会包含一个虚函数表指针（vptr），这个指针指向该对象所属类的虚函数表。当调用虚函数时，实际上是通过vptr找到了该对象所属类的虚函数表，并从表中获取对应虚函数的地址进行调用。 虚函数表指针一般是放在对象的最开始位置，这样可以方便地通过对象的指针访问到它。当然，具体实现还要看编译器的实现方式。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值