这部分的内容主要是记住使用方法，原理在之后会讲。
多态的概念
多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。
比如说买票，普通人买票就是正常买，学生可以买学生票，军人可以优先买票。对于同一个行为，不同的对象去完成会产生不同的结果。即不同的对象去调用这个函数(买票)，会得到不同的结果。
多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。实现多态首先要存在被继承的基类，其次还存在两个条件：
1. 必须通过基类的指针或者引用调用虚函数
2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写(也叫覆盖)
虚函数是被virtual修饰的成员函数，修饰方法是在函数返回值前加上virtual。
虚函数的重写：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数
示例：
class person
{
public:
virtual void BuyTicket() { cout << "普通人 全价-100" << endl; }
private:
string _name;
};
class student : public person
{
public:
//基类和派生类的成员函数前面如果都没有加上virtual，派生类函数名和基类相同，构成隐藏，要调用基类函数要声明作用域。
//前面加上了virtual，且函数名，函数参数，返回值相同，构成重写(也叫覆盖)
virtual void BuyTicket() { cout << "学生 半价-50" << endl; }
};
class soldier : public person
{
public:
virtual void BuyTicket() { cout << "军人 优先买票 全价-100" << endl; }
};
下面来看看应用场景，添加如下代码：
void Pay(person* ptr)
{
ptr->BuyTicket();
//运行后发现，虽然都是person类型的指针调用了BuyTicket函数，但是运行的结果不一样
cout << endl;
}
int main()
{
person p;
student st;
soldier so;
int option = 0;
do
{
cout << "请输入：";
cout << "1：学生 2：军人 3：普通人" << endl;
cin >> option;
switch (option)
{
case 1:
Pay(&st);
//只要传不同类型的对象，就可以达到不同的行为
break;
case 2:
Pay(&so);
break;
case 3:
Pay(&p);
break;
default:
cout << "输入错误，请重新输入" << endl;
}
} while (option != -1);
return 0;
}
运行结果：
将内容变的稍微复杂一点：
class person
{
public:
person(string name)
:_name(name)
{}
virtual void BuyTicket()
{
cout << _name <<" 普通人 全价-100" << endl;
}
protected:
//需要被继承的成员对象要定义成公有或者保护
string _name;
};
class student : public person
{
public:
student(string name)
:person(name)
{}
virtual void BuyTicket()
{
cout << _name << " 学生 半价-50" << endl;
}
};
class soldier : public person
{
public:
soldier(string name)
//基类没有默认构造函数，就需要自己显式调用基类构造函数，完成基类部分的初始化
:person(name)
{}
virtual void BuyTicket()
{
cout << _name << " 军人 优先买票 全价-100" << endl;
}
};
void Pay(person* ptr)
{
ptr->BuyTicket();
delete ptr;
cout << endl;
}
int main()
{
int option = 0;
do
{
cout << "请输入：";
cout << "1：学生 2：军人 3：普通人" << endl;
cin >> option;
string name;
cout << "请输入姓名：";
cin >> name;
switch (option)
{
case 1:
Pay(new student(name));
//不能通过匿名对象完成传参，原因不明
break;
case 2:
Pay(new soldier(name));
break;
case 3:
Pay(new person(name));
break;
default:
cout << "输入错误，请重新输入" << endl;
}
} while (option != -1);
return 0;
}
多态的实现存在两个条件（需要背下来）：
1.派生类虚函数重写基类虚函数（重写的条件：返回值，函数名，函数参数相同+虚函数）
2.基类指针或者引用调用虚函数
这两个条件中的任意一点不满足都会导致无法实现多态。
这些条件和虚函数表有关，会在多态原理中了解，目前只需要记住就可以了。
当然，存在一些看似不符合条件，实际上能符合条件的情况
1.协变：对返回值要求的例外，如果返回值满足派生类的返回值(B*)为其基类返回值(A*)的派生类，则视为满足返回值相同。返回值类型必须是指针或对象引用。
class A{};
class B : public A {};
class Person
{
public:
virtual A* f()
{
cout << "virtual A* f() " << endl;
return nullptr;
}
};
class Student : public Person
{
public:
virtual B* f()
{
cout << "virtual B* f() " << endl;
return nullptr;
}
};
int main()
{
Person p;
Student s;
Person* ptr;
ptr = &p;
ptr->f();
ptr = &s;
ptr->f();
return 0;
}
2.派生类虚函数没有写virtual依然被认为是虚函数，因为先继承了基类的函数接口声明，重写了基类虚函数的实现。具体见最后。
我们自己写代码的时候要在派生类中加上virtual的，不加virtual是一种很不好的习惯。
析构函数的重写
class Person
{
public:
virtual ~Person() {cout << "~Person()" << endl;}
};
class Student : public Person
{
public:
virtual ~Student() { cout << "~Student()" << endl; }
};
int main()
{
Person p;
Student S;
return 0;
}
按照先定义的后析构，先子后父的顺序，完成析构。加上virtual也一样，所以构不构成重写不影响普通对象的析构顺序
如果基类没有virtual，就不会构成多态，那么ptr->destructor()就是普通的函数调用，无法构成多态，也就不会调用student的析构函数，student的内存没有释放会导致内存泄漏。
关于destructor，编译器会把所有类的析构函数处理成destructor的形式，就是为了满足此时多态的需求(虚函数+函数名，函数参数，返回值相同)，只有满足多态了，才能保证ptr = new Student; delete ptr能释放合适的空间(delete是根据指针类型来调用析构函数释放空间的，只有构成多态才能保证基类指针调用派生类析构函数)。所以在继承的部分，在派生类的析构函数中调用基类的析构函数且不声明作用域会报错（虽然派生类会在结束自动调用基类的析构函数，不需要再调用，但这里只是解释一下为什么在派生类调用基类的析构函数会报错，即使派生类和基类都没有成员变量(有成员变量就可能需要释放空间，对一个空间释放两次就会报错)），两种析构函数都被处理成destructor的形式了，会导致无限递归。
如果设计一个可能被继承的类，首先，成员函数、成员变量最好定义为保护；其次，析构函数最好定义为虚函数。这样能保证析构函数被正常的析构。
整个机制的逻辑关系：继承->继承的切片->基类指针可能指向派生类->delete基类指针只能调用基类析构函数->将析构函数都处理成destructor()->满足多态条件->完成基类指针调用派生类析构函数
c++11 override和final
从上面可以看出，C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失，因此：C++11提供了override和fifinal两个关键字，可以帮助用户检测是否重写。
final：修饰虚函数，表示虚函数不可被重写
class Car
{
public:
virtual void Drive() final {}
//final的使用方式
};
class Benz :public Car
{
public:
virtual void Drive() {cout << "Benz-舒适" << endl;}
};
上面这部分代码会在编译时报错。
之前有提到过实现一个不可被继承的类，当时的方法是将构造函数私有化，但是这是间接的不可继承，如果没有创建派生类，那么，即使派生类继承了基类，也不会报错。而final可以使类直接的不可继承，即在类名后加上final，示例:class Car final。表示最终类，不可被继承。
override：检查派生类的虚函数是否重写了基类的某个虚函数，如果没有重写则编译报错。
class Car
{
public:
virtual void Drive(){}
};
class Benz :public Car
{
public:
virtual void Drive() override
//override的使用方式
{cout << "Benz-舒适" << endl;}
};
override一定是写在派生类当中的。
重载，重写，重定义三者的区别：
抽象类
在虚函数的后面写上 =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;
}
};
int main()
{
Car* pBenz = new Benz;
pBenz->Drive();
Car* pBMW = new BMW;
pBMW->Drive();
return 0;
}
在没有指明具体是什么车时，车是一个抽象的概念。指明具体对象后就能通过多态展现具体的特点。
如果在BMW的成员函数中加上参数，则new BMW会报错，这暗示BMW继承了car的纯虚函数，即使构成了隐藏，但car中的纯虚函数还是在BMW类中了，导致BMW变成了抽象类，无法实例化出对象。
接口继承和实现继承
普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现（抽象类中的普通函数，未被重写的虚函数，也可以被实现继承）。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口(所以没有写virtual也会被认定是虚函数)，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。经过实际检验，没有重写的接口继承会变成实现继承。
下面是一道选择题：
答案是B
所以只要派生类返回值，函数名，函数参数与基类相同，就会继承接口，构成重写，就能实现多态。凡是实现接口继承的，必能实现多态。
