C++之多态

梅塔文·欧帕西安卡琼

已于 2024-06-13 11:04:43 修改

阅读量114

点赞数 1

分类专栏： C++ 文章标签： c++

于 2023-08-25 21:44:01 首次发布

本文链接：https://blog.csdn.net/a20040518/article/details/131384363

版权

C++ 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

1.多态的概念

多态：相同的行为方式导致了不同的行为结果，同一行语句展现了不同的表现形态，即多态性。

举例：去游乐场，儿童票半价，成人票全价，老人票免费。对比类来说的话，买票就是一个类的一个方法（函数）。儿童、成人、老人就是对象，这些对象调用同一个买票函数得出来不同的票价，这就是一种多态。

C++多态，父类指针可以指向任何继承该类的子类对象，父类指针具有子类的表现形态，多种子类表现多种形态，由父类指针统一管理，那么这个父类指针就具有了多种形态，即多态。

多态的实现需要满足以下条件: 存在继承关系，子类重写父类的虚函数，父类指针或引用指向子类对象。

重写：在继承条件下，子类定义了与父类中虚函数一模一样的函数（包括函数名，参数列表，返回值）我们称之为重写。

#include<iostream>
using namespace std;
class CFather
{
public:
	virtual void fun()
	{
		cout << "CFather::fun" << endl;
	}
};
class CSon :public CFather
{
public:
	virtual void fun()//重写了父类的虚函数，这里即使省略virtual也会认为是虚函数
	{
		cout << "CSon::fun" << endl;
	}
};
int main()
{
	CFather* pfa = new CSon; //指针形式
	pfa->fun();  //CSon::fun 正规使用虚函数

	CSon son;
	CFather& fa = son; //引用
	fa.fun();  //CSon::fun

	fa.CFather::fun();  //CFather::fun 静态绑定 编译期确定了父类的函数
}

注：

int main()
{
	//父类指针指向子类对象 是多态
	CFather* pFa = new CSon; 
	pFa->fun(); //CSon::fun
	//子类指针指向子类对象 不是多态
	CSon* pSon = new CSon;  
	pSon->fun(); //CSon::fun
}

回顾：在以往学的继承中，我们无法通过父类指针调用子类不统一的函数，而在上一篇中，我们通过类成员函数指针解决了这一问题。学了多态后，这个问题就很简单了。

我们直接在父类中创建一个eat虚函数，子类重写父类的虚函数，这样父类指针就能指向子类不统一的函数了。

#include<iostream>
using namespace std;
class CPeople
{
public:
	int m_money;
	CPeople() :m_money(10) {};
	void cost(int n)
	{
		m_money -= n;
		cout << "买吃的" << endl;
	}
	void walk()
	{
		cout << "跑" << endl;
	}
	virtual void eat(){}
};
class CWhite :public CPeople
{
public:
	CWhite() {}
	void eat()
	{
		cout << "吃汉堡" << endl;
	}
};
class CYellow :public CPeople
{
public:
	CYellow() {}
	void eat()
	{
		cout << "吃米饭" << endl;
	}
};
class CBlack :public CPeople
{
public:
	CBlack() {}
	void eat()
	{
		cout << "吃手抓饭" << endl;
	}
};

void fun(CPeople* p)
{
	p->cost(2);
	p->eat(); 
	p->walk();

}
int main()
{
	fun(new CWhite);
	fun(new CYellow);
	fun(new CBlack);
}

2.虚函数

百度百科：https://mr.baidu.com/r/1kAhi53fsek?f=cp&rs=1318128787&ruk=bmFc6uUUFGlkkW3f2m3nDg&u=8a56a9c323bb517d

几个关键点：

1. 虚函数必须使用virtual关键字声明。
2. 虚函数必须是类的非静态成员函数，且不能是构造函数。
3. 虚函数的访问权限可以是public、protected或private，但对于多态性来说，通常定义为public。

我们知道，空类所占空间为一个字节，如果在类中创建一个普通函数，那么类所占空间仍为一个字节，因为普通函数不会占用类的空间。但是如果在类中创建一个或多个虚函数，那么此时类就占四个字节了。

结论：类所占内存空间与虚函数有关，但与虚函数的数量无关。（x86 32位操作系统下占4个字节，x64 64位操作系统下占8个字节）

测试代码：

#include<iostream>
using namespace std;

class CTest
{
public:
	void fun1()
	{
		cout << 1 << endl;
	}
	virtual void fun2()
	{
		cout << 2 << endl;
	}
	virtual void fun3()
	{
		cout << 3 << endl;
	}
};

int main()
{
	cout << sizeof(CTest) << endl;//4
}

虚函数指针

在一个类中，当存在虚函数时，在定义对象的内存空间首地址会多分配出一块内存，在这块内存中增加一个指针变量（二级指针void**），也就是虚函数指针__vfptr。

1.属于对象的，由编译器默认添加，可以看做是一般的成员属性。定义对象时才存在（此时会分配内存空间），多个对象多份指针，并且每个对象的虚函数指针指向的是同一个虚函数列表。
2.在构造的初始化列表中进行初始化（编译器默认完成）。

虚函数列表（vftable）：是一个函数指针数组，数组每个元素为类中虚函数的地址。

几个关键点：

1.属于类的，在编译期存在，为所有对象共享。

2.必须通过真实存在的对象调用，无对象或空指针对象无法调用虚函数。

虚函数调用流程：

模拟虚函数调用流程：

	CTest tst;
	//模拟虚函数调用流程
	typedef void (*P_FUN)();
	P_FUN p_fun1 = (P_FUN)((int*)(*(int*)&tst))[0];
	P_FUN p_fun2 = (P_FUN)((int*)(*(int*)&tst))[1];
	(*p_fun1)();
	(*p_fun2)();

虚函数与普通成员函数的区别：

1.调用流程不同：虚函数的调用流程比普通成员函数复杂得多，这是他们的本质区别。

2.调用效率不同：普通成员函数通过函数名（即函数入口地址）直接调用函数，效率高且速度快。虚函数调用需要虚函数指针和虚函数列表的参与，效率低且速度慢。

3.使用场景不同：虚函数指针主要用于实现多态，一般情况下普通函数无法完成。

虚函数实现多态缺点：

（1）效率问题：调用虚函数效率低且速度慢。

（2）空间问题：定义每一个对象都会额外开辟指针大小的空间，虚函数列表占用程序的内存空间，并且会随着继承层级递增，占用的空间会越来越大。

（3）安全问题：通过其他方法可以模拟虚函数的调用，人为的跨过访问修饰符的限制。因此。私有的函数最好不要变为虚函数，否则会出现安全隐患。

3.多态实现的原理

1. 前提：虚函数列表是属于类的，父类和子类都会有各自的虚函数列表，__vfptr是属于对象的，每个对象都有各自的__vfptr。
2. 原理：

1.子类继承父类，不但继承了父类的成员，也会继承父类的虚函数列表。

2.编译器会检查子类是否有重写父类的虚函数。如果有，在子类的虚函数列表中会替换掉父类的虚函数，一般称之为覆盖，覆盖后便指向了子类的虚函数。

3.如果子类没有重写的父类虚函数，父类虚函数会保留在子类的虚函数列表中。

4.如果子类定义了独有的虚函数，按顺序依次添加到虚函数列表结尾。

注：表格中的内容在编译阶段就已完成
3. 流程：父类指针指向子类对象，__vfptr在子类的初始化参数列表中被初始化，指向子类的虚函数列表，申请哪个子类对象__vfptr就指向了哪个子类的虚函数列表。调用虚函数时执行虚函数的调用流程，则实现了多态。

4.纯虚函数

纯虚函数是一种特殊的虚函数，在许多情况下，在基类中不能对虚函数给出有意义的实现，而把它声明为纯虚函数，将它的实现留给该基类的派生类去实现。这就是纯虚函数的作用。

声明：virtual void function()=0; 这里注意纯虚函数一定没有定义，只需声明即可。

特点：当前类不必实现，但子类必须重写实现父类的纯虚函数。

#include<iostream>
using namespace std;
//抽象类：包含纯虚函数的类 称之为抽象类，是不允许定义对象的。
class CPeople {
public:
	//纯虚函数：在一般的虚函数后加上=0; 只声明 不需要定义，在子类中一定要重写这个纯虚函数
	virtual void eat() = 0;
};

//具体类：
class CTeacher :public CPeople {
public:
	virtual void eat() {  //必须要重写父类的纯虚函数
		cout << "我在学习" << endl;
	}

};
int main() {
	CPeople* p = new CTeacher;
	p->eat();
}

注：包含纯虚函数的类叫抽象类，抽象类不能实例化对象（也就是不允许定义对象）。继承这个抽象类的派生类叫具体类，具体类必须重写定义抽象类里面的所有的纯虚函数。

5.虚析构

问：在多态下，父类的指针指向子类的对象。最后在回收空间的时候，是按照父类的指针类型delete的，所以只调用了父类的析构，子类的析构并没有执行，这样的话就有可能导致内存泄漏。那么该如何处理？


	CFather* pFa = new CSon;
	pFa->~CFather(); //ok
	pFa->~CSon(); //error
    delete pFa;  //注：delete自动调用哪个析构函数，取决于传递指针的类型
	pFa = nullptr;

解决：利用虚析构，即把父类的析构函数变为虚析构，在delete pFa时，调用析构会发生多态行为，从而真正调用的是子类的析构，最后回收对象内存空间时，再调用父类的析构。

利用代码来理解：

#include<iostream>
using namespace std;
class CFather {
public:
	CFather() {
		cout << __FUNCSIG__ << endl;
	}
	virtual ~CFather() { //虚析构
		cout << __FUNCSIG__ << endl;
	}
};
class CSon :public CFather {
	int* m_p;
public:
	CSon() {
		m_p = new int(1);
		cout << __FUNCSIG__ << endl;
	}
	~CSon() {
		cout << __FUNCSIG__ << endl;
		if (m_p)
			delete m_p;
		m_p = nullptr;
	}
};
int main()
{
	CFather* P = new CSon;
	P->~CFather(); //ok
	delete P;
	P = nullptr;
}

注：在多态下，父类的析构一定为虚析构。