C++进阶(2):多态

多态的概念

多态分为编译时多态(静态多态)和运行时多态(动态多态)。
**编译时多态：**主要就是我们前面讲的函数重载和函数模版。之所以叫编译时多态，是因为实参传给形参的参数匹配是发生在编译时完成的（ps：通常把编译时一般归为静态，运行时归为动态）
**运行时多态：**就是去完成某个行为(函数)，可以传不同的对象就会完成不同的行为，就达到多种形态。

多态的定义及实现

多态的构成条件

多态是一个继承关系 下的类对象，去调用同一函数，产生了不同的行为。

实现多态还有两个必要重要条件

必须基类的指针或者引用调用虚函数
被调用的函数必须是虚函数

说明：要实现多态的效果

必须是基类的指针或引用，因为只有基类的指针或引用才能既指向派生类对象，又指向基类对象；
派生词必须对基类的虚函数重写/覆盖(三同)，重写或者覆盖了，派生类才能有不同的函数，多态的不同形态效果才能达到。

虚函数

类成员函数前面加virtual修饰，那么这个成为函数被称为虚函数。注意非成员函数不能加virtual修饰。

class Person
{
public:
	virtual void BuyTicket()
	{
		count<<"买票—全价"<<endl;
	}
};

虚函数的重写/覆盖

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

⚠️ 在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写(因为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性)，但是该种写法不是很规范，不建议这样使用，不过在考试中，经常会故意买这个坑，让你判断是否构成多态。

class Person{
public:
	virtual void BuyTicket()
	{
		cout<<"买票-全价"<<endl;
	}
};

class class: public Person{
public:
	virtual void BuyTicket()
	{
		cout<<"买票-打折"<<endl;
	}
};

void Func(Person* ptr)//这里也可以用引用，那么在调用时不用取地址了
{
	//这里可以看到虽然都是Person的指针ptr在调用BuyTicket
	//但是跟ptr没关系，而是由ptr指向的对象决定的
	ptr->BuyTicket();
}

int main()
{
	Person ps;
	Student st;

	Func(&ps);
	Func(&st);
}

虚函数重写的一些其他问题

协变(了解)

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

class A{};
class B:public A{};

class Person{
public:
	virtual A* BuyTicket()
	{
		cout<<"买票-全价"<<endl;
	}
};

class class: public Person{
public:
	virtual B* BuyTicket()
	{
		cout<<"买票-打折"<<endl;
	}
};

void Func(Person* ptr)
{
	ptr->BuyTicket();
}

int main()
{
	Person ps;
	Student st;

	Func(&ps);
	Func(&st);
}

析构函数的重写

基类的析构函数为虚函数，此时派生类析构函数只要定义，无论加不加virtual关键字，都与基类的析构函数构成重写。
虽然基类与派生类析构函数名字不同看起来不符合重写的规则，实际上编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor，所以基类的析构函数加了virtual修饰，派生类的析构函数就构成重写了。

class A
{
	public:
		virtual ~A()
		{
			count<<"~A()"<<endl;
		}
};

class B: public A
{
	public:
		(virtual) ~B()
		{
			count<<"～B()"<<endl;
			delete _p;
		}
	
	protected:
		int* _p=new int[10];
};

//只要派生类Student的析构函数重写了Person的析构函数，下面的delete对象调用析构函数，才能构成多态，才能保证p1和p2指向的对象正确的调用析构函数。
int main()
{
	A*p1=new A;
	A*p2=new B;

	delete p1;//destructor+operator delete
	delete p2;//先子后父

	return 0；
}

上面的代码我们可以看到，如果～A()，不加virtual，那么delete p2时只调用的A的析构函数，没有调用B的析构函数，就会导致内存泄露问题，因为～B()中在释放空间。

⚠️这个问题经常考察，一定要知道为什么基类中的析构函数建议设计成虚函数。

override和final关键字

C++对虚函数重写的要求较为严格，但是有些情况下由于疏忽，比如函数名写错参数写错等导致无法构成重写，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失，因此C++11提供了两个关键字：

override : 可以帮助用户检测是否重写
final : 使派生类无法重写这个虚函数

//error C3668:"Benz::Drive":包含重写说明符’override‘的方法没有重写任何基类方法
class Car
{
public:
	virtual void Drive()
	{}
 };
 
 class Benz :public Car 
 {
 public:
	virtual void Drive() override 
	{ cout << "Benz-#" << endl; }
 };

int main()
{
	return 0;
}

//error C3248:“Car::Drive”:声明为‘final’的函数无法被"Benz::Drive"重写
class Car
{
public:
	virtual void Drive() final
	{}
 };
 
 class Benz :public Car 
 {
 public:
	virtual void Drive()  
	{ cout << "Benz-#" << endl; }
 };

int main()
{
	return 0;
}

重载/重写/隐藏的对比

在这里插入图片描述

纯虚函数和抽象类

在虚函数的后面写上“=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()
	{
		count<<"BMW-操控"<<endl;
	}
};

int main()
{
	Car car;//编译报错：error C2259:"Car":无法实例化抽象类

	Car* pBenz=new Benz;
	pBenz->Drive();
	
	Car* pBMW=new BMW;
	pBMW->Drive();
	
	return 0;
}

多态的原理

虚函数表指针

在一个虚函数中，除了有它的对象外，还多了一个__vfptr(virtual function table)放在对象的前面或者后面，对象中的这个指针叫做虚函数表指针。一个含有虚函数的类中至少都有一个虚函数表指针，因为一个类所有虚函数的地址要被放到这个类对象的虚函数表中，虚函数表也简称虚表。

数组->指针数组->函数指针数组

在这里插入图片描述

多态的原理

多态是如何实现的

从底层的角度Func函数中ptr->BuyTicket()，是如何作为ptr指向Person对象调用Person::BuyTicket，ptr指向Student对象调用Student::BuyTicket的呢？
在这里插入图片描述
ptr指向的Person对象调用Person的虚函数
ptr指向的Student对象调用Student的虚函数

通过上图我们可以看出，满足多态条件后，底层不再是编译时通过调用对象确定函数的地址，而是运行时到指向的对象的虚表中确定对应的虚函数的地址，这样就实现了指针或引用指向基类就调用基类的虚函数，指向派生类就调用派生类对应的虚函数。

动态绑定与静态绑定

静态绑定： 对不满足多态条件(指针或者引用＋调用虚函数)的函数调用是在编译时绑定，也就是编译时确定调用函数的地址。
动态绑定： 满足多态条件的函数调用是在运行时绑定，也就是在运行时到指向对象的虚函数表中找到调用函数的地址。

虚函数表

基类对象的虚函数表中存放基类所有虚函数的地址。
派生类由两部分构成，继承下来的基类和自己的成员。一般情况下，继承下来的基类中有虚函数表指针，自己就不会再生成虚函数表指针。但是要注意的这里继承下来的基类部分虚函数表指针和基类对象的虚函数表指针不是同一个，就像基类对象的成员和派生类对象中的基类对象成员也是独立的。
同类型对象虚表共用，不同类型对象不共用虚表
派生类中重写的基类的虚函数，派生类的虚函数表中对应的虚函数就会被覆盖成派生类重写的虚函数地址。
派生类的虚函数表中包括，基类的虚函数地址，派生类重写的虚函数地址，派生类自己的虚函数地址 三个部分。
虚函数表本质是一个存虚函数指针的指针数组，一遍情况是这个数组最后放一个0x00000000标记。（这个C++并没有进行规定，各个编译器自行定义的。）
虚函数和普通函数一样，编译好后是一段指令，都是存在代码块 中，只是虚函数的地址又存放在虚函数表中。但是虚函数表的位置却没有明确的规定。