C++ 底层分析 5.动态绑定、多态

最新推荐文章于 2023-05-17 17:23:33 发布
最新推荐文章于 2023-05-17 17:23:33 发布
阅读量156 收藏
点赞数
分类专栏： 编程 逆向 文章标签： 多态 指针 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mikasys/article/details/115362976
版权
本文探讨了C++中的多继承和虚函数表的实现细节，包括无函数覆盖和有函数覆盖的情况。在多继承中，每个基类都有自己的虚函数表，子类的虚函数表会包含所有基类的虚函数。当有函数覆盖时，子类的重写函数会替换基类的相应函数。此外，还解释了前期绑定与动态绑定的概念，指出只有virtual函数才具备动态绑定特性，实现多态。最后，提出了析构函数为何需要声明为virtual的原因，以确保正确调用析构路径。
摘要由CSDN通过智能技术生成

1.多继承无函数覆盖

struct Base1						
{		
	int a;
	int b;				
public:	
	Base1()
	{
		a = 1;
		b = 2;
	}
    virtual void Fn_1()						
    {						
        printf("Base1:Fn_1...\n");						
    }						
    virtual void Fn_2()						
    {						
        printf("Base1:Fn_2...\n");						
    }						
};						
struct Base2						
{			
	int a;
	int b;			
public:		
	Base2()
	{
		a = 3;
		b = 4;
	}			
    virtual void Fn_3()						
    {						
        printf("Base2:Fn_3...\n");						
    }						
    virtual void Fn_4()						
    {						
        printf("Base2:Fn_4...\n");						
    }						
};						
struct Sub:Base1,Base2						
{
	int a;
	int b;						
public:	
	Sub()
	{
		a = 5;
		b = 6;
	}
    virtual void Fn_5()						
    {						
        printf("Sub:Fn_5...\n");						
    }						
    virtual void Fn_6()						
    {						
        printf("Sub:Fn_6...\n");						
    }						
};						
int main(int argc, char* argv[])						
{						
	//查看 Sub 的虚函数表					
    Sub sub;						
						
	//通过函数指针调用函数，验证正确性					
    typedef void(*pFunction)(void);						
										
	//对象的前四个字节是第一个Base1的虚表					
	printf("Sub 的虚函数表地址为：%x\n",*(int*)&sub);					
						
	pFunction pFn;					
						
	for(int i=0;i<6;i++)					
	{					
		int temp = *((int*)(*(int*)&sub)+i);				
		if(temp == 0)				
		{				
			break;			
		}				
		pFn = (pFunction)temp;				
		pFn();				
	}					
						
	//对象的第4个四字节是Base2的虚表					
	printf("Sub 的虚函数表地址为：%x\n",*(int*)((int)&sub+0xC));					
	
	pFunction pFn1;					
	
	for(int k=0;k<2;k++)					
	{					
		int temp = *((int*)(*(int*)((int)&sub+0xC))+k);				
		pFn1 = (pFunction)temp;				
		pFn1();				
	}					
	
	return 0;					
}

总结：
在这里插入图片描述
在这里插入图片描述
有几个父类就有几个表
子类的虚函数放在第一个表

2.多继承有函数覆盖

struct Base1					
{					
public:					
    virtual void Fn_1()					
    {					
        printf("Base1:Fn_1...\n");					
    }					
    virtual void Fn_2()					
    {					
        printf("Base1:Fn_2...\n");					
    }					
};					
struct Base2					
{					
public:					
    virtual void Fn_3()					
    {					
        printf("Base2:Fn_3...\n");					
    }					
    virtual void Fn_4()					
    {					
        printf("Base2:Fn_4...\n");					
    }					
};					
struct Sub:Base1,Base2					
{					
public:					
    virtual void Fn_1()					
    {					
        printf("Sub:Fn_1...\n");					
    }					
    virtual void Fn_3()					
    {					
        printf("Sub:Fn_3...\n");					
    }					
	virtual void Fn_5()				
    {					
        printf("Sub:Fn_5...\n");					
    }					
};					
int main(int argc, char* argv[])					
{					
	//查看 Sub 的虚函数表				
    Sub sub;					
					
	//通过函数指针调用函数，验证正确性				
    typedef void(*pFunction)(void);						
	//对象的前四个字节是第一个Base1的虚表				
	printf("Sub 的虚函数表地址为：%x\n",*(int*)&sub);				
				
	pFunction pFn;				
					
	for(int i=0;i<6;i++)				
	{				
		int temp = *((int*)(*(int*)&sub)+i);			
		if(temp == 0)			
		{			
			break;		
		}			
		pFn = (pFunction)temp;			
		pFn();			
	}				
					
	//对象的第二个四字节是Base2的虚表				
	printf("Sub 的虚函数表地址为：%x\n",*(int*)((int)&sub+4));				
					
	pFunction pFn1;				
					
	for(int k=0;k<2;k++)				
	{				
		int temp = *((int*)(*(int*)((int)&sub+4))+k);			
		pFn1 = (pFunction)temp;			
		pFn1();			
	}								
	return 0;				
}

总结：
在这里插入图片描述

3.多层继承有函数覆盖

struct Base1			
{			
public:			
    virtual void Fn_1()			
    {			
        printf("Base1:Fn_1...\n");			
    }			
    virtual void Fn_2()			
    {			
        printf("Base1:Fn_2...\n");			
    }			
};			
struct Base2:Base1			
{			
public:			
    virtual void Fn_3()			
    {			
        printf("Base2:Fn_3...\n");			
    }			
};			
struct Sub:Base2			
{			
public:			
	virtual void Fn_1()		
    {			
        printf("Sub:Fn_1...\n");			
    }			
	virtual void Fn_3()		
    {			
        printf("Sub:Fn_3...\n");			
    }			
};			
int main(int argc, char* argv[])			
{			
	//查看 Sub 的虚函数表		
    Sub sub;			
			
	//观察大小：虚函数表只有一个		
	printf("%x\n",sizeof(sub));		
			
	//通过函数指针调用函数，验证正确性		
    typedef void(*pFunction)(void);			
			
			
	//对象的前四个字节是就是虚函数表		
	printf("Sub 的虚函数表地址为：%x\n",*(int*)&sub);		
			
	pFunction pFn;		
			
	for(int i=0;i<6;i++)		
	{		
		int temp = *((int*)(*(int*)&sub)+i);	
		if(temp == 0)	
		{	
			break;
		}	
		pFn = (pFunction)temp;	
		pFn();	
	}		
			
	return 0;		
}

总结：从上往下最后一个重写函数才会写入虚函数表
在这里插入图片描述

4.前期绑定与动态绑定

绑定：就是将函数调用与地址关联起来。
前期绑定：又称编译期绑定，即编译时已将函数地址写入，E8直接call
后期绑定：又称动态绑定、运行期绑定，即编译时没有直接写入地址，而是FF间接call
多态：相同的调用产生不同的行为

class Base				
{				
public:				
	int x;			
public:				
	Base()			
	{			
		x = 100;		
	}			
    void Function_1()				
    {				
        printf("Base:Function_1...\n");				
    }				
    virtual void Function_2()				
    {				
        printf("Base:Function_2...virtual\n");				
    }				
};				
class Sub:public Base				
{				
public:				
	int x;			
public:				
	Sub()			
	{			
		x = 200;		
	}			
    void Function_1()				
    {				
        printf("Sub:Function_1...\n");				
    }				
    virtual void Function_2()				
    {				
        printf("Sub:Function_2...virtual\n");				
    }				
};				
void TestBound(Base* pb)			
{			
	int n = pb->x;		
	printf("%x\n",n);		
			
	pb->Function_1();		//函数调用
			
	pb->Function_2();		
}			
int main(int argc, char* argv[])			
{			
    Base base;//Sub base;
    TestBound(&base);
	return 0;		
}

当传入对象为Sub指针
在这里插入图片描述
当传入对象为Base指针
在这里插入图片描述
运行结果：
Base base;
在这里插入图片描述
Sub base;
在这里插入图片描述
总结：

  1. 只有virtual的函数是动态绑定.
  2. 动态绑定还有一个名字：多态

5.作业

在这里插入图片描述

#include<string>
#include <iostream>

using namespace std;
class Base		
{		
public:		
	int x;	
	int y;
public:		
	Base()	
	{	
		x = 1;
		y = 2;
	}	
    void Print()		
    {		
        printf("Base:%x %x\n",x,y);		
    }			
};		
class Sub1:public Base		
{			
public:	
	int A;

	Sub1()	
	{	
		 x = 4;
		 y = 5;
		 A = 6;
	}	
    void Print()		
    {		
        printf("Sub1:%x %x %x\n",x,y,A);		
    }	
};		


class Sub2:public Base		
{			
public:	
	int B;
	Sub2()	
	{	
		x = 7;
		y = 8;
		B = 9;
	}	
    void Print()		
    {		
        printf("Sub2:%x %x %x\n",x,y,B);		
    }	
};		
class Sub3:public Base		
{			
public:	
	int C;
	Sub3()	
	{	
		x = 10;
		y = 11;
		C = 12;
	}	
    void Print()		
    {		
        printf("Sub3:%x %x %x\n",x,y,C);		
    }	
};	
void TestBound()		
{		
	Base b;
	Sub1 s1;
	Sub2 s2;
	Sub3 s3;
	
	Base* arr[] = {&b,&s1,&s2,&s3};
	for(int i=0;i<4;i++)
	{
		arr[i]->Print();
	}
}

不写成virtual
在这里插入图片描述
写成virtual
在这里插入图片描述
思考题：为什么析构函数写成virtual？
定义成虚函数才能准确退出，不然类用完不知道调用的哪个析构函数

Mikasys
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++常见面试题及详细解答(C++基础)
大脑白质的博客
09-08 2272
1.关于c++内存对齐 内存对齐原因： (1). 平台原因(移植原因)：不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。 (2). 性能原因：数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问 #include <cassert>...
C++的动态捆绑机制
Evan_work的博客
03-25 522
当编译器发现我们的类中有虚函数的时候，编译器会创建一张虚函数表，把虚函数的函数入口地址放到虚函数表中，并且在类中秘密增加一个指针，这个指针就是vpointer(缩写vptr)，这个指针是指向对象的虚函数表。 在多态调用的时候，根据vptr指针，找到虚函数表来实现动态绑定。 当虚函数涉及到继承的时候 子类 会继承 父类的（虚函数指针vfptr 虚函数表vftable） 编译器会将虚函数表中的函数入...
C++ 动态多态实现底层逻辑
fckbb的博客
05-17 2089
📖在C++中，动态多态是通过虚函数(Virtual Function)和运行时类型识别(Run-time Type Identification, RTTI)来实现的。📖虚函数是在基类中声明的函数，在派生类中可以被重写(Override)，并且通过基类指针或引用调用时，会根据实际对象的类型来调用相应的派生类函数，而不是基类函数。这种调用方式被称为动态绑定(Dynamic Binding)。📖运行时类型识别允许程序在运行时获取对象的类型信息。dynamic_cast和typeid。
C++学习笔记之继承与派生
qq_42524389的博客
01-13 298
定义一个shape类，在此基类基础上派生Rectangele 和circle类，二者都有getarea()函数计算对象的面积，使用Rectangele 类创建一个派生类square类。 #include<iostream> using namespace std; class shape{ public: virtual double getarea() = 0; }; class Rectangle :public shape{ private: double longth; d.
C7-3 用类实现a+b (100/100 分数)
weixin_30609331的博客
05-17 180
题目描述 下面的代码声明了两个基类Base1和Base2，然后从这两个基类按照公有方式派生出类Derived。基类和派生类都各自包含一个公有成员x，并且Base1和Base2各有接受一个整型参数的构造函数，Derived的构造函数接受Base1和Base2的对象引用a，b来初始化Derived类对象，并令x为Base1::x和Base2::x之和。请将下面的代码补充完成，使得输出符合要求。 #...
哈工大计算机系统大作业-C、C++底层分析代码.zip
06-29
分析C++的底层不仅涉及C语言的基础，还涉及到虚函数表、动态绑定、构造函数与析构函数的调用顺序等高级主题。C++的模板元编程和STL（标准模板库）也是底层分析的重点，这些特性如何转化为机器码，以及它们对运行时...
关于继承多态及动态绑定.pdf
12-05
总的来说，继承、多态和动态绑定是C++中实现面向对象编程的关键特性，它们使得代码更加灵活，易于扩展，同时也提供了强大的代码复用机制。通过理解这些概念及其底层实现，可以更好地设计和实现复杂的软件系统。
c++病理打码系统.zip
最新发布
10-08
5. **多态**：C++通过虚函数和纯虚函数实现运行时多态，允许子类重写父类的方法，实现动态绑定。 6. **底层控制**：C++保留了C语言的底层特性，如指针操作，能直接访问内存，适合开发系统级软件和高性能应用。 在...
从汇编看c++中多态的应用
09-05
虚函数使得子类能够重写基类的行为，而vtable则提供了动态绑定（或称为运行时绑定）的能力，使得在不知道具体对象类型的情况下，仍能调用合适的函数实现。这种机制在设计模式如工厂方法、抽象工厂和策略模式中尤其...
C、C++笔试面试宝典.pdf
08-13
- 多态：同一消息可以有不同的响应，实现动态绑定。 5. 析构函数： - 子类析构函数在执行时，会自动调用基类的析构函数，以确保正确清理所有资源。这遵循了构造和析构的反向顺序原则。 6. 引用： - 引用是已...
iostream
UncleJokerly
03-22 2358
#include 是个包含命令，就是把iostream.h这个文件里的内容复制到这个地方ostream.h是input output stream的简写，意思为标准的输入输出流头文件。它包含： （1）cin>>"要输入的内容" （2）cout 这两个输入输出的方法需要#include来声明头文件。 iostream.h与iostream是不同的。 #include是在旧的标准C++中使用
C++面试题
热门推荐
backard的专栏
01-20 5万+
1.构造一个类MySingleton,使该类只能存在一个实例. 思路:     将构造函数写为private的，然后通过一个成员静态函数来调用构造函数即可:) 例: #include "iostream.h" class MySingleton { private: static MySingleton* _instance; MySingleton(){ cout ~MyS
协议基类 struct p_base 理解
YEYUANGEN的专栏
09-02 1564
问： // 协议基类 struct p_base { p_base(int protocol_code,int protocol_len):p_name(protocol_code),p_len(protocol_len) {} int p_name; int
VC++----using namespace std问题
奔跑的蜗牛
08-06 3287
写一个简单的代码 #include //using namespace std; struct Point { int x; int y; }; void main() { Point pt; pt.x=5; pt.y=5; cout<<pt.x<<endl<<pt.y<<endl; } 竟然报错 1>g:\c++\c工程示例\lesson2_point\less
C++动态多态之动态绑定机制的细节分析
liuyf_666的博客
05-14 579
C++动态多态之动态绑定机制的细节分析前言正文总结 前言 最近在研究关于多态特性的知识，众所周知，动态绑定（或称动态联编）(•́⌄•́๑)૭✧是动态多态的实现基础，而实现动态绑定的重要基础是虚函数，正是有了动态绑定机制，使得基类指针作为一个接口同时能调用派生类和基类中的函数，即所谓的一个接口，多种实现，本文不会全面讲述动态多态的实现细节，而是着重于分析动态绑定的底层机制，如有不妥之处，欢迎指正。 ...
C++ 编程的基本问题
风从北边来的博客
10-27 300
#include &lt;iostream&gt; using namespace std; struct MyStru { int val; MyStru(int v) { val = v; } };//类和结构体定义时需要加上分号 class CBase { public: CBase(){printf("construct CBase\n");} //private://...
第6章 C++面向对象2
chenyijun的专栏
09-17 1014
C语言是面向过程的，而C++作为C语言的超集支持，它是面向对象的。面向对象（Object Oriented）是当前计算机界关心的重点，它是当今软件开发方法的主流，因此也是各大公司的重要考点。
C++ 动态绑定
weixin_48853167的博客
05-12 1557
C++中使用继承可以定义相似类型的类并对其相似关系建模。 C++的动态绑定可以帮助程序在一定程度上忽略相似类（基类和派生类）的差别而使用相同的处理方式来处理对象。 定义两个类： class book { public: book() { m_price = 0.0; m_sailed_n = 0; m_min_n = 10; } ~book() {} string isbn(void) const ...
c++ virtual 动态绑定（类的底层实现）
qq_45760401的博客
05-12 375
说到c++的动态绑定，就不得不提到类在内存中的存储了，因为动态绑定 从原理上来谈，与c++类的内存存储分别不开。 首先，什么是类，我们知道，编译器会将c++的代码编译成汇编代码， 而汇编代码又分为 堆区、栈区、代码区、全局/静态区、常量区，其实类就 相当于是这些区域的数据的耦合。 对于类的成员方法，一般放到代码区里面，而类的常量和静态变量（方法） 分别放置在常量区和静态全局区，但是类的变量一般是没有存储的，因为变量会 随着对象的不同而改变，所以平常所说的对象，其实就是堆区、栈区变量的集合体。 对于对.
深入理解C++对象模型：从基础到多态
C++对象模型是理解C++编程语言核心机制的关键，它涉及到类、对象、继承、多态等核心概念的底层实现。在C++中，对象模型是编译器如何在内存中表示类及其实例的抽象描述。以下是基于给定的章节内容对C++对象模型的详细...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值