C++进阶-多态

1.多态的概念

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

2.多态的定义及实现

2.1多态的构成条件

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了
Person。Person对象买票全价，Student对象买票半价。
多态的两个条件：
1.虚函数的重写（父子类虚函数，要求三同（函数名、参数、返回值））
2.父类的指针或引用去调用虚函数

2.2 虚函数

虚函数：即被virtual修饰的类成员函数称为虚函数

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

2.3虚函数的重写

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

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

//Person &p参数会将实参，基类对象，派生类参数赋值给他时会切边
void Func(Person& p)
{
	p.BuyTicket();
}

int main()
{
	Person ps;
	Student st;

	Func(ps);
	Func(st);
	return 0;
}

虚函数重写的两个例外：

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

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

class Student : public Person {
public:
	// 重写
	virtual B* BuyTicket() {
		cout << "买票-半价" << endl;
		return nullptr;
	}
};

两个虚函数的返回值时虚函数的指针或引用
是多态：调用一个全价，一个半价

2.析构在虚函数中的重写:析构函数建议定义成虚函数
如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。

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

	// destructor()  析构函数悄悄该成destructor，为了子类析构函数够成重写
	virtual ~Person() { cout << "~Person()" << endl; }
};

class Student : public Person {
public:
	// 重写
	virtual Student* BuyTicket() {
		cout << "买票-半价" << endl;
		return nullptr;
	}

	// destructor()
	virtual ~Student()
	{ 
		cout << "~Student()" << endl;
	}

private:
	int* _ptr = new int[10];
};

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

int main()
{
	//析构函数调用错误
	//第一种情况
	Person ps;
	Student st;
    
	return 0;
}

第一种情况:会出现都是析构的是正确的

第二种情况：会出现都是析构的Person的析构函数的问题

析构函数=析构函数+operator delete(p1)
没有形成多态，所以不会走Student的析构函数
期望：指向父类调用父类析构
期望：指向子类调用子类析构

由于没有形成多态，而且是Person对象的指针，则就只会执行Person的析构函数
析构函数析构时会全部变成destructer（），没有虚函数时构成隐藏，有虚函数时构成重写
则要形成多态，才会调用指向谁就调用谁的析构，则要给虚构函数添加virtual

建议析构函数定义为虚函数，防止发生内存泄漏

接下来有两个特殊事例
第一个示例

// A: A->0 B : B->1 C : A->1 D : B->0 E : 编译出错 F : 以上都不正确
class A
{
   
   
public:
	virtual void func(int val = 1) {
   
    std::cout << "A->" << val << std::endl; }

	virtual void test() {
   
    func(); }
};

class B : public A
{
   
   
public:
	void func(int val = 0) {
   
    std::cout << "B->" << val << std::endl; }
};

int main(int argc, char* argv[])
{
   
   
	B* p = new B;
	p->test();

	return 0;
}

这里代码结果与想象的结果不一样

重写：重写的是虚函数的实现（父类的声明，子类的实现），函数的结构部分（函数名参数返回值）用的是父类的，就相当于父类的函数名继承下来，然后重写实现。

第二个示例

//A:p1==p2==p3	B:p1<p2<p3	C:p1==p3!=p2	D:p1!=p2!=p3
class Base1 {
   
    public: int _b1; };
class Base2 {
   
    public: int _b2; };
class Derive : public Base1, public Base2 {
   
    public: int _d; };

int main() {
   
   
	Derive d;
	Base1* p1 = &d;
	Base2* p2 = &d;
	Derive* p3 = &d;

	return 0;
}

p1是Base1对象指针，p2是Base2对象指针，p3是继承Base1，Base2下来的Derive对象指针，则是所以p1和p3是相同的地址，p2跟在p1的后面。

如果改为如下代码

class Base1 {
   
    public: int _b1; };
class Base2 {
   
    public: int _b2; };
class Derive : public Base2, public Base1 {
   
    public: int _d; };

int main() {
   
   
	Derive d;
	Base1* p1 = &d;
	Base2* p2 = &d;
	Derive* p3 = &d;

	return 0;
}

则从监视窗口可以看见

Base1和Base2颠倒继承顺序，由于派生类先继承的在前面，后继承的在后面，所以Base2会在Base1前面生成。

先继承的在前面，后继承的在后面。

2.4 C++11 override和final

C++11提供了override和final两个关键字，可以帮助用户检测是否重写。
1.final：修饰虚函数，表示该虚函数不能再被重写，也可以修饰类，表示类无法被继承
Car类中的虚函数不能重写到Benz中

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

一个类无法被继承方法
（1）.finally修饰
（2）.C++98方法：父类的构造函数私有（无法建立对象）

// 一个不能类被继承
class Car
// C++11的方法: final修饰的类叫最终类，不能继承
class Car final
{
   
   
public:

private:
	// C++98的方法：父类的构造函数私有
	// 子类的构造无法生成和实现，导致子类对象无法实例化
	Car()
	{
   
   }
};

class Benz :public Car
{
   
   
public:

};

2. override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错

class Car {
   
   
public:
	virtual void Drive()