多态

多态

概念
同一个方法，在不同的场景下，可以表现出不同的行为。
分类
分为静态多态和动态多态；

静态多态（静态绑定、静态联编、早绑定）：在编译期间，就可以确定函数的行为，即：具体调用哪个函数
体现：函数重载、模板

动态多态（动态绑定、动态联编、晚绑定）：在程序运行时，根据基类指针或引用指向不同类的对象，调用对应的虚函数（在程序运行时，确定函数具体的行为）。
动态多态实现条件
虚函数：即被virtual修饰的类成员函数称为虚函数。

class Person {
public:
 virtual void BuyTicket() { cout << "买票-全价" << endl;}
 //该函数即为虚函数
};

前提：继承体系下

1. 基类中必须要有虚函数，子类必须要对基类中的虚函数进行重写；
2. 虚函数调用：必须通过基类的指针或引用来调用虚函数；

两个条件缺一不可，否则无法实现多态；

如果两个条件已经完全满足了，在程序运行时，根据基类的指针或者引用指向不同类的对象选择对应类的虚函数进行调用。

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

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

class Student : public Person
{
public:
	virtual void Buyticket() {cout << "半价票" << endl;}
	//在重写基类虚函数时，派生类的虚函数不加virtual关键字也可以构成重写（继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性），但是不建议这样使用；
};

void Func(Person& p) { p.Buyticket();}

int main()
{
	Person ps;
	Student st;
	
	Func(ps);
	Func(st);
	
	return 0;
}

虚函数的例外：
析构函数的重写（基类与派生类析构函数的名字不同）
如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同；

class Person {
public:
	virtual ~Person() { cout << "~Person()" << endl; }
};
class Student : public Person {
public:
	virtual ~Student() { cout << "~Student()" << endl; }
};
// 只有派生类Student的析构函数重写了Person的析构函数，下面的delete对象调用析构函数，才能构成多态，才能保证p1和p2指向的对象正确的调用析构函数。
int main()
{
	Person* p1 = new Person;
	Person* p2 = new Student;
	delete p1;
	delete p2;
	return 0;
}

重写	同名隐藏
基类函数必须为虚函数	可以为虚函数，也可以不是
子类虚函数必须要与基类虚函数的原型一致	同名即可
必须是虚函数重写，不能是成员变量重写	函数可以同名隐藏，成员变量也行

重写要求非常严格，不注意就可能是同名隐藏，就不能实现多态；

C++11 中override和final
override
只能修饰子类虚函数，而且一定是子类的虚函数；
作用：让编译器在编译代码期间，帮助检测子类中某个虚函数是否对基类中虚函数进行重写，如果重写成功则编译通过，否则编译失败；

class Car
{
public:
	virtual void Drive() {}
};

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

final：
修饰类：表面该类不能被继承；
修饰成员函数：修饰虚函数，表示虚函数不需要被子类重写；

class Car
{
public:
	virtual void Drive() final {}
	//该虚函数不能被继承
};
class Benz :public Car
{
public:
	virtual void Drive() { cout << "Benz-舒适" << endl; }
};

多态的实现原理

class Base
{
public:
	virtual void Func() { cout << "Func()" << endl; }
private:
	int _b = 1;
};
int main()
{
	cout << sizeof(Base) << endl;
	system("pause");
}//最后结果为8

b对象是8字节，还多了一个_vfptr放在对象前,对象中的这个指针叫虚函数表指针（v：virtual，f：function）；
一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表；

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 _b = 1;
};
class Derive : public Base
{
public:
	virtual void Func1() { cout << "Derive::Func1()" << endl; }
private:
	int _d = 2;
};

int main()
{
	Base b;
	Derive d;
	return 0;
}

通过上述代码测试：
1.派生类类对象d中也有一个虚表指针；
2.基类类b对象和派生类d对象虚表是不一样；发现Func1完成了重写，所以d的虚表中存的是重写的Derive::Func1；
3.Func2继承下来后是虚函数，放进了虚表；Func3也继承下来了，但不是虚函数，所以不会放进虚表。
4.虚函数表本质是一个存虚函数指针的指针数组，这个数组最后面放了一个nullptr。

所以，派生类的虚表生成：
a.先将基类中的虚表内容拷贝一份到派生类虚表中 ；
b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数；
c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后；
抽象类
纯虚函数：在虚函数的后面写上 =0；
包含纯虚函数的类叫做抽象类；
特性：
a.抽象类不能实例化对象
b.子类需要对抽象类中的纯虚函数进行重写，否则子类也是抽象类；

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();
}