C++多态的实现原理，虚函数超级详解

最新推荐文章于 2023-06-30 12:26:44 发布

遥远的歌s

最新推荐文章于 2023-06-30 12:26:44 发布

阅读量328

点赞数 2

分类专栏： C++ 文章标签： C++ 多态

本文链接：https://blog.csdn.net/qq_44819750/article/details/107504492

版权

C++ 专栏收录该内容

36 篇文章 3 订阅

订阅专栏

多态的概念

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

举个栗子：比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票。

再举个栗子：最近为了争夺在线支付市场，支付宝年底经常会做诱人的扫红包-支付-给奖励金的活动。那么大家想想为什么有人扫的红包又大又新鲜8块、10块…，而有人扫的红包都是1毛，5毛…。其实这背后也是一个多态行为。支付宝首先会分析你的账户数据，比如你是新用户、比如你没有经常支付宝支付等等，那么你需要被鼓励使用支付宝，那么就你扫码金额 = random()%99；比如你经常使用支付宝支付或者支付宝账户中常年没钱，那么就不需要太鼓励你去使用支付宝，那么就你扫码金额 = random()%1；总结一下：同样是扫码动作，不同的用户扫得到的不一样的红包，这也是一种多态行为。ps：支付宝红包问题纯属瞎编，大家仅供娱乐。

多态定义及实现

上述例子我们可以知道，多态其实就是再继承关系中，不同的子类对象调用同一函数，产生不同的行为。
首先要明确，多态必须要在继承关系中才能实现
其次必要条件
1. 必须通过基类的指针或者引用调用虚函数
2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写
3. 函数调用必须通过父类对象指针或对象
注意：
虚函数：即被virtual修饰的类成员函数称为虚函数。
虚函数重写

class person
{
public:
	virtual void ticket()//父类虚函数
	{
		cout<<"全价"<<endl;
	}
};
class student:public person//公有继承父类
{
public:
	virtual void ticket()//子类对虚函数的重写
	{
		cout<<"半价"<<endl;
	}
};
//实现多态
void fun(person& p)//需要用引用或者指针
{
	p.ticket();
}
void test()
{
	person pe;
	fun(pe);//会打印全价

	student st;
	fun(st);//会打印半价
}

在这里插入图片描述

派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。

class person
{
public:
	virtual void ticket()
	{
		cout<<"全价"<<endl;
	}
};
class student:public person
{
public:
	virtual void ticket()
	{
		cout<<"半价"<<endl;
	}
};
 /*注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写(因为继 承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性),但是该种写法不是很规范，不建议这样使用 */

虚函数重写的两个例外

协变(基类与派生类虚函数返回值类型不同) 派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。

class A{}; 
class B : public A {};//B为派生类，A为基类
class Person 
{ 
public:    
	virtual A* f() {return new A;} //基类返回基类
};
class Student : public Person 
{ 
public:    
	virtual B* f() {return new B;} //派生类返回派生类
};

在这里插入图片描述

析构函数的重写(基类与派生类析构函数的名字不同) 如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。
比如：以下代码，我们通过new来从堆上开辟对象，如果说

class Person
{
public:
  Person()
  {
    cout<<"创建Persond对象资源"<<endl;
  }
   ~Person()
  {
    cout<<"释放Person对象资源"<<endl;
  }
};
class Student : public Person
{
public:
  Student()
  {
    cout<<"创建Student对象资源"<<endl;
  }
  ~Student()
  {
    cout<<"释放Student对象资源"<<endl;
  }
};
void test2()
{
  cout<<"开辟堆上的空间"<<endl;
  Person *ptr = new Person;
  Student *str = new Student;//通过Student指针开辟一个对象
  delete ptr;
  delete str;
}

如下图这样的申请和释放是没有任何问题的。
在这里插入图片描述
但是如果用父类的指针来申请子类的对象，再释放的时候就会出现问题，如下

void test2()
{
  cout<<"开辟堆上的空间"<<endl;
  Person *ptr = new Person;
  Person *str = new Student;//用Person类指针申请Student对象
  delete ptr;
  delete str;
}

在这里插入图片描述
为了防止这样的情况产生，则规定父类的析构函数用virtual关键字修饰，而子类的析构函数则不需要用该关键字修饰，只要父类的析构函数是虚函数，编译器就会帮我们将子类的析构函数和父类的析构函数构成一种重写关系，这是因为编译器对继承关系下的所有类的析构函数d的名字做了统一的处理，即子类的析构函数和父类的析构函数的函数名称在底层是相同的，即destructor。
注意：在这里千万不要在子类中重写父类的析构函数，编译器不支持这样的语法

class Person
{
public:
  Person()
  {
    cout<<"创建Persond对象资源"<<endl;
  }
  virtual ~Person()//父类的析构函数写成虚函数
  {
    cout<<"释放Person对象资源"<<endl;
  }
};
class Student : public Person
{
public:
  Student()
  {
    cout<<"创建Student对象资源"<<endl;
  }
  ~Student()
  {
    cout<<"释放Student对象资源"<<endl;
  }
};

这样再执行之前的代码结果为
在这里插入图片描述
多态看实际指向的类型，即使你是父类指针，但是我指向的是子类对象，那么在释放子类对象资源时，子类对象的析构函数就会自动调用父类的析构函数，完成整个资源的释放。
提示：如果在代码中需要从堆上申请对象，并且整个代码体系中存在继承关系，则建议将父类的析构函数写成虚函数。这样会避免内存泄露的问题发生。

override和ﬁnal关键字

ﬁnal：修饰虚函数，表示该虚函数不能被重写，子类中只能用这个函数

class Car 
{ 
public:    
	virtual void Drive() final {} 
};
class Benz :public Car 
{ 
public:    
	virtual void Drive() {cout << "Benz-舒适" << endl;} 
};

上述代码编译就会报错
在这里插入图片描述

override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错，即必须要重写父类中的虚函数。

class Car
{ 
public:    
	virtual void Drive(){} 
};
 
class Benz :public Car 
{
public:    
	virtual void Drive(int a = 10) override 
	{
	cout << "Benz-舒适" << endl;
	} 
};

上述代码编译不通过，原因使子类中没有重写父类的虚函数，则会报错
在这里插入图片描述

抽象类

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。
抽象类的存在就是为了实现多态

class Car //抽象类
{ 
public:    virtual void Drive() = 0; //纯虚函数，没有函数体
};
class Benz :public Car 
{ 
public:    
	virtual void Drive()    
	{      
		cout << "Benz-舒适" << endl;    
	} 
};
class BMW :public Car 
{ 
public:    
	virtual void Drive()    
	{        
		cout << "BMW-操控" << endl;    
	} 
};
void Test() 
{    
	Car* pBenz = new Benz;
    pBenz->Drive();
    Car* pBMW = new BMW;    
    pBMW->Drive(); 
  }

多态实现原理

一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表，虚表中只存访指向虚函数的函数指针。
下面这个例子，输出是多少呢？

class Car//抽象类
{
public:
	virtual void Drive(){}//纯虚函数
};
void test()
{
  cout<<sizeof(Car)<<endl;
}

在这里插入图片描述
这是因为该该抽象类中存在一个虚函数指针(在64位机器下的执行)，大小为8个字节
再比如下述例子：

class Base 
{ 
public:    
	virtual void Func1()    
	{        
		cout << "Base::Func1()" << endl;    
	}
    virtual void Func2()    
    {        
  		cout << "Base::Func2()" << endl;    
  	}
    void Func3()    
    {        
    	cout << "Base::Func3()" << endl;    
    }
private:    
	int _d = 1; 
};
class Derive : public Base 
{ 
public:    
	virtual void Func1()    
	{        
		cout << "Derive::Func1()" << endl;    
	} 
private:    
	int _b = 2; 
}; 
int main() 
{    
	Base b;    
	Derive d;
    return 0; 
}

因为基类中对Func1，Func2函数为虚函数，自裂中对Func1函数重写，但是子类中仍然继承了基类中的Func2虚函数，则会存放在子类的需表中，对于重写的虚函数，子类中会有自己指向该函数的指针，而没有重写的虚函数，则指向的是和父类中一样的虚函数。
上述代码在vs中监视如下图：
在这里插入图片描述
进一步说，对于基类对象来说，有一个虚函数表指针_vfptr，它指向虚函数表的首地址，他有两个元素，存的是虚函数指针分别是指向虚函数Func1，Func2，而对于子类对象来说，也有一个虚函数表和一个虚函数指针，但是，这里存的Func1函数重写了，子类就会用自己的函数指针指向该函数，而Func2没有重写，则子类中存放的还是父类中的Func2函数。
对上述的总结：

派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员，虚表指针也就是存在部分的另一部分是自己的成员。
基类b对象和派生类d对象虚表是不一样的，这里我们发现Func1完成了重写，所以d的虚表中存的是重写Derive::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。
另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函数，所以不会放进虚表。
虚函数表本质是一个存虚函数指针的指针数组，这个数组最后面放了一个nullptr。
总结一下派生类的虚表生成：a.先将基类中的虚表内容拷贝一份到派生类虚表中 b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数 c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。
这里还有一个童鞋们很容易混淆的问题：虚函数存在哪的？虚表存在哪的？答：虚函数存在虚表，虚表存在对象中。注意上面的回答的错的。但是很多童鞋都是这样深以为然的。注意虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。
看出满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象的中取找的。不满足多态的函数调用时编译时确认好的。

动态绑定与静态绑定

静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载
动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。

单继承中的虚函数表

typedef void(*VFPTR) (); 
void PrintVTable(VFPTR vTable[]) 
{    // 依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数    
	cout << " 虚表地址>" << vTable << endl;    
	for (int i = 0; vTable[i] != nullptr; ++i)    
	{        
		printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);        
		VFPTR f = vTable[i];        
		f();    
	}    
	cout << endl; 
}

int main() 
{    
	Base b;    
	Derive d;
 
    // 思路：取出b、d对象的头4bytes，就是虚表的指针，前面我们说了虚函数表本质是一个存虚函数指针的指针数组，这个数组最后面放了一个nullptr    
    // 1.先取b的地址，强转成一个int*的指针    
    // 2.再解引用取值，就取到了b对象头4bytes的值，这个值就是指向虚表的指针    
    // 3.再强转成VFPTR*，因为虚表就是一个存VFPTR类型(虚函数指针类型)的数组。    
    // 4.虚表指针传递给PrintVTable进行打印虚表    
    // 5.需要说明的是这个打印虚表的代码经常会崩溃，因为编译器有时对虚表的处理不干净，虚表最后面 没有放nullptr，导致越界，这是编译器的问题。我们只需要点目录栏的-生成-清理解决方案，再编译就好了。    		
    VFPTR* vTableb = (VFPTR*)(*(int*)&b);    
    PrintVTable(vTableb);
 
    VFPTR* vTabled = (VFPTR*)(*(int*)&d);    
    PrintVTable(vTabled);
 
    return 0; 
}

在这里插入图片描述
多继承中的虚函数表

class Base1 
{ 
public:    
	virtual void func1() {cout << "Base1::func1" << endl;}    
	virtual void func2() {cout << "Base1::func2" << endl;} 
private:    
	int b1; 
};

class Base2 
{ 
public:    
	virtual void func1() {cout << "Base2::func1" << endl;}    
	virtual void func2() {cout << "Base2::func2" << endl;} 
private:    
	int b2; 
};
class Derive : public Base1, public Base2 
{ 
public:    
	virtual void func1() {cout << "Derive::func1" << endl;}    
	virtual void func3() {cout << "Derive::func3" << endl;} 
private:    
	int d1; 
};

typedef void(*VFPTR) (); 
void PrintVTable(VFPTR vTable[]) 
{    
	cout << " 虚表地址>" << vTable << endl;    
	for (int i = 0; vTable[i] != nullptr; ++i)    
	{        
	printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);        
	VFPTR f = vTable[i];        
	f();    
	}    
	cout << endl; 
}

int main() 
{    
	Derive d;
    VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);    PrintVTable(vTableb1);

    VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d+sizeof(Base1)));    
    PrintVTable(vTableb2);

    return 0; 
}

观察下图可以看出：多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中
在这里插入图片描述

遥远的歌s

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
4
评论
C++多态的实现原理，虚函数超级详解

多态的概念多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。举个栗子：比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优先买票。再举个栗子：最近为了争夺在线支付市场，支付宝年底经常会做诱人的扫红包-支付-给奖励金的活动。那么大家想想为什么有人扫的红包又大又新鲜8块、10块…，而有人扫的红包都是1毛，5毛…。其实这背后也是一个多态行为。支付宝首先会分析你的账户数据，比如你是新用户、比如你没有经常支付宝支付等等
复制链接

扫一扫