继承关系作用下虚函数的手工调用

于 2022-04-26 00:08:07 发布
阅读量908 收藏
点赞数
分类专栏： C++新经典对象模型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46272577/article/details/124417915
版权

虚函数 虚函数表 派生类 函数指针 继承
关键词由CSDN通过智能技术生成

通过虚函数表指针调用虚函数

创建一个父类，一个子类，尝试着通过虚函数表指针调用虚函数

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

int main()
{
	cout << sizeof(Base) << endl;	// 4
	cout << sizeof(Derive) << endl;	// 4
	cout << sizeof(long) << endl;
	
	Derive* d = new Derive(); // 派生类指针，其实用基类指针指向派生类也一样 Base *d = new Derive()
	long* pvptr = (long*)d;
	long* vptr = (long*)(*pvptr);

	for (int i = 0; i <= 4; i++) {
		printf("vptr[%d] = 0x:%p\n", i, vptr[i]);
	}
	typedef void(*Func)(void); // 定义了一个函数指针，typedef就代表Func是一个函数指针类型，可以将它当作类型使用
	Func f = (Func)vptr[0];
	Func g = (Func)vptr[1];
	Func h = (Func)vptr[2];
	Func i = (Func)vptr[3];
	Func j = (Func)vptr[4];
	f();
	g();
	h();
	//i();
	//j();

	return 0;
}

分析代码

着重分析一下下面的代码

Derive* d = new Derive(); // 派生类指针，其实用基类指针指向派生类也一样 Base *d = new Derive()
long* pvptr = (long*)d;
long* vptr = (long*)(*pvptr);
  • Derive *d = new Derive();
  • long *pvptr = (long *)d;
  • long *vptr = (long*)(*pvptr);
  • 未强制类型转换前，d指向的是创建出的Derive的整个对象大小的内存空间的首地址
  • 我们实质只关注这个类对象的内存空间中的存虚函数表首地址内存的那部分中的空间，也就是long类型大小的空间（一个指针变量的大小也就占long这么长），此时pvptr就是单纯的指向Derive对象的虚函数表首地址的那部分内存
  • long *vptr = (long*)(*pvptr); *pvptr是虚函数表首地址的值，将这个值强制类型转换为一个long类型地址值，即vptr是一个指向long类型的指针变量，它的值就是虚函数表首地址。
    ————————————————
    版权声明：本文为CSDN博主「NGC_2070」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
    原文链接：https://blog.csdn.net/baidu_41388533/article/details/109497379

自己的理解

  • 我们想要得到虚函数表里的函数地址，但是最开始获得的是对象的开始地址，即d，而我们要找到虚函数的地址就需要先找到虚函数表指针，而虚函数表指针在对象的开头并且指针的长度为long，所以我们可以通过强制类型转换限制指向的内存，即long *pvptr = (long *)d，此时得到的pvptr就是虚函数表指针的那段地址。
  • 但是仅仅这样还是无法直接遍历得到虚函数，比如使用for(; ; )每次增加1，对于pvptr指针来说是在对象的内存中增加一个long的大小，我们得到是虚函数的地址吗，显然不是。所以我们先要得到虚函数表指针所指的值(解引用)，然后再让新的指针指向它，即long *vptr = (long*)(*pvptr)，*pvptr即虚函数表的地址，对地址强制类型转换是需要加*的，然后再让一个新的指针指向此处被转换的地址，对这个vptr指针进行遍历，其增加1，就是在虚函数表地址开头那增加一个long，此时获得的就是不同的虚函数了
  • 第二点可以换句话说，我们需要在虚函数表的那块内存上循环遍历得到，而pvptr是在虚函数表指针的那块内存上循环遍历，所以需要解引用并且强制转换
img

使用定义的函数指针调用虚函数

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

int main()
{
	cout << sizeof(Base) << endl;	// 4
	cout << sizeof(Derive) << endl;	// 4
	cout << sizeof(long) << endl;
	
	Derive* d = new Derive(); // 派生类指针，其实用基类指针指向派生类也一样 Base *d = new Derive()
	long* pvptr = (long*)d;
	long* vptr = (long*)(*pvptr);

	for (int i = 0; i <= 4; i++) {
		printf("vptr[%d] = 0x:%p\n", i, vptr[i]);
	}
	typedef void(*Func)(void); // 定义了一个函数指针，typedef就代表Func是一个函数指针类型，可以将它当作类型使用
	Func f = (Func)vptr[0];
	Func g = (Func)vptr[1];
	Func h = (Func)vptr[2];
	Func i = (Func)vptr[3];
	Func j = (Func)vptr[4];
	f();	// Base::f
	g();	// Derive::g 子类覆盖父类的虚函数
	h();	// Base::h
	//i();
	//j();

	return 0;
}

4
4
4
vptr[0] = 0x:00B71104
vptr[1] = 0x:00B71078
vptr[2] = 0x:00B714D3
vptr[3] = 0x:00000000
vptr[4] = 0x:69726544
Base::f()
Derive::g()
Base::h()

我们发现前面vptr[]三个的地址在一个范围内，后面两个距离有些远

我们使用自定义的函数指针，调用虚函数表里面的函数，从上到下依次是

Base::f()
Derive::g()
Base::h()

这符合我们所想的空间布局，Derive继承父类，所以虚函数表里有父类的虚函数，然后因为Derive自定义了Derive::g()，所以覆盖了父类的Base::g()我们得到的是子类的函数。

再增加父类对象虚函数表的打印

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

int main()
{
	cout << sizeof(Base) << endl;	// 4
	cout << sizeof(Derive) << endl;	// 4
	cout << sizeof(long) << endl;
	
	cout << "对子类" << endl;
	Derive* d = new Derive(); // 派生类指针，其实用基类指针指向派生类也一样 Base *d = new Derive()
	long* pvptr = (long*)d;
	long* vptr = (long*)(*pvptr);

	for (int i = 0; i <= 4; i++) {
		printf("vptr[%d] = 0x:%p\n", i, vptr[i]);
	}
	typedef void(*Func)(void); // 定义了一个函数指针，typedef就代表Func是一个函数指针类型，可以将它当作类型使用
	Func f = (Func)vptr[0];
	Func g = (Func)vptr[1];
	Func h = (Func)vptr[2];
	Func i = (Func)vptr[3];
	Func j = (Func)vptr[4];
	f();
	g();
	h();
	//i();
	//j();

	
	Base* dpar = new Base();
	long* pvptrpar = (long*)dpar;
	long* vptrpar = (long*)(*pvptrpar);

	cout << "对父类" << endl;
	for (int i = 0; i <= 4; i++) {
		printf("vptr_Base[%d] = 0x:%p\n", i, vptrpar[i]);
	}
	Func fpar = (Func)vptrpar[0];
	Func gpar = (Func)vptrpar[1];
	Func hpar = (Func)vptrpar[2];
	Func ipar = (Func)vptrpar[3];
	Func jpar = (Func)vptrpar[4];
	fpar();
	gpar();
	hpar();


	return 0;
}

4
4
4
对子类
vptr[0] = 0x:00611104
vptr[1] = 0x:00611078
vptr[2] = 0x:006114D3
vptr[3] = 0x:00000000
vptr[4] = 0x:69726544
Base::f()
Derive::g()
Base::h()
对父类
vptr_Base[0] = 0x:00611104
vptr_Base[1] = 0x:00611226
vptr_Base[2] = 0x:006114D3
vptr_Base[3] = 0x:00000000
vptr_Base[4] = 0x:65736142
Base::f()
Base::g()
Base::h()

总结

  • 父类对象调用的虚函数都是父类的
  • 父类子类虚函数表所指向的虚函数首地址：[0] [2]都相同，都代表Base::f() Base::h()的首地址，而[1]不同，代表子类Derive::g()的首地址和父类Base::g()的首地址

参考

Last-Week
关注
专栏目录
C++ 类 函数 变量
小秋 AI SLAM 入门实战教程
12-13 1786
在C++中, 用 “类” 来描述 “对象”, 所谓的"对象"是指现实世界中的一切事物。那么类就可以看做是对相似事物的抽象, 找到这些不同事物间的共同点, 如自行车和摩托车, 首先他们都属于"对象", 并且具有一定得相同点, 和一些不同点, 相同点如他们都有质量、都有两个轮子, 都是属于交通工具等。“都有质量”、"两个轮子"属于这个对象的属性, 而"都能够当做交通工具"属于该对象具有的行为, 也称方法。类是属于用户自定义的数据类型, 并且该类型的数据具有一定的行为能力, 也就是类中说描述的方法。
python下的橡皮线_ObjectARX常用类和函数
weixin_34642354的博客
02-03 1085
2019独角兽企业重金招聘Python工程师标准>>> (1)AcAx 开头的全局函数：这些函数通过 COM 的方式来让AutoCAD 完成一些操作。(a)acutPrintf函数：在 AutoCAD 命令行显示指定的字符串acutPrintf函数的具体用法如例：acutPrintf("\n输入不合法，请重新输入");(b)AcAxMove 函数：移动实体。需要链接 axau...
C++ - 继承虚函数调用 代码
Mystra
09-12 2780
继承虚函数调用 代码本文地址:http://blog.csdn.net/caroline_wendy派生类继承基类时, 使用virtual时, 会进行动态绑定, 没有virtual关键字则会覆盖.使用基类指针(Base*)指向派生类时, 调用函数, 则动态绑定的函数会调用派生类, 非动态绑定的函数调用基类.代码:/* * main.cpp * * Created on: 2014.9.1
继承关系作用下的虚函数手工调用
qq_38158479的博客
06-25 206
#include<iostream> #include<stdio.h> using namespace std; class A { public: virtual void x() {cout<<"x()"<<endl;} virtual void y() {cout<<"y()"<<endl;} virtual void z() {cout<<"z()"<<endl;} }; c
类继承时的虚函数调用关系
迎风的舵手
06-06 1263
#include using namespace std; class A { public: virtual void func(); virtual int operator=(int n); virtual A& operator= (const A&); }; void A::func() { cout<<"A::func()"<<endl; } int A::operat
多态二：带有虚函数的虚拟继承
xuruhua的博客
12-03 493
        1、普通函数的继承 class Base { public: virtual void Test1() { cout &lt;&lt; "B::Test1()" &lt;&lt; endl; } virtual void Test2() { cout &lt;&lt; "B::Test2()" &lt;&lt; endl; } int _b; };...
effective C++之子类虚函数调用基类函数
不积跬步无以至千里
10-29 456
深度探索C++对象模型（8）——虚函数（1）——虚函数表指针的位置和虚函数表分析
波波鱼的博客
01-15 829
1.虚函数表指针的位置分析 一个类有虚函数的话，会产生一个虚函数表 而生成这个类的对象的时候，这个对象就会产生一个指针，指向虚函数表的开始位置，这个指针就是虚函数指针（vptr）,有种类似于这个对象的成员变量，它是占字节数的，如在vs2017中占4个字节，在Linux下占8个字节 而vptr在对象内存中的位置取决于编译器 分析虚函数表指针的位置分析的代码： #include &lt;i...
为什么要使用虚函数和 指针（或是引用）才能实现多态？
一座青山的专栏
03-14 4510
首先说说为什么是这样一个题目 最近我在学习《深度探索C++对象模型》这本书，明白了C++对象模型的内存布局。但也恰巧是这个内存布局让我有一次陷入了深深的疑惑之中。先看看我的例子： 注：此例也是引用某位博主的，只是搜索的内容太多了，找不到原连接的位置了……。#include using namespace std; class Shape//形状 { public: virtual
虚函数与堆栈
dxbo12的专栏
03-02 616
静态成员函数的作用是什么? 在C++中静态成员函数也是类函数，及这个函数不属于某个具体的对象，而是属于一个类的，这个类实例化的每个成员都可用，同时，这个类也可以直接调用这个函数而不用实例化一个对象。 堆和栈的区别 1、栈区（stack）― 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。 2、堆区（heap）
虚函数的调用问题（关于派生类、基类，派生类中声明的虚函数）
qq_45586976的博客
04-23 2393
感觉放几张图大家就应该清楚了： 这是以A类作为基类指针，但是最初只在B中声明的虚构函数的调用问题，明显，虚函数并没有起作用 这里添加了以B为直接基类的派生类D，仍以A类作为基类指针，但是最初只在B中声明的虚构函数的调用问题，明显，虚函数并没有起作用 这里添加了以B为直接基类的派生类D，以B类作为基类指针，但是最初只在B中声明的虚构函数的调用问题，明显，虚函数起作用了 并且，明显可以看出，...
虚函数调用问题
liuyongli1992的博客
09-09 395
1. #include  using namespace std; class A { public:     int a;     A(int aa = 1) { a = aa; }      void print() {         cout      } }; class B : public A { public:     int a;     B(
c++中调用基类虚函数的方法
weixin_44881103的博客
07-10 3603
以下展示实例： #include using namespace std; class Base{ public: virtual void file() { cout << “Base—” << endl; } }; class Test:public Base{ public: virtual void file() { cout << “Test ----” << endl; } }; int main() { Base *b=new Test();
C++虚函数介绍以及在多层继承中调用 & 在多重继承中调用
天道酬勤
07-21 2719
C++虚函数在多层继承中调用 & 在多重继承中调用1 多层继承1.1 介绍1.2 示例2 多重继承 1 多层继承 1.1 介绍 在一个类中的虚函数说明，只对派生类中重定义的函数有影响，对它的基类中的函数不起作用。 1.2 示例 class A { public: virtual void show() { std:...
C++中继承，虚函数的调用问题
nhf_a的博客
05-06 483
类继承代码如下 问：调用输出的结果是什么 class CA { public: virtual void fun1() { cout } void fun2() { fun1(); cout } }; class CB:public CA { public: virtual void fun1() { cout } void fun2() { fun
【C++】继承（二）多继承，虚函数，虚继承
hgelin的博客
09-18 7082
1.单继承与多继承 2.菱形继承 3.虚继承---解决菱形继承的二义性和数据冗余的问题 4.虚函数与多态 5.继承体系同名函数的关系   1.单继承与多继承  1.1单继承：       一个子类只有一个直接父类。   class Person class Student : public Person class Monitor : public Student  1.2多继...
逆向C++：从手工到自动化分析
2) 虚函数表识别：分析虚函数表以确定类的多态性。 3) 构造/析构函数搜索：根据函数调用模式识别类。 4) 继承关系识别：通过分析函数指针和内存布局来推断继承。 5) 类成员识别：通过内存访问模式和函数调用来查找...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值