C++多态的理解

概念

多态：就是多种形态。
静态的多态 — 函数重载
动态的多态 — 父类指针或引用调用虚函数
1.父类指针或引用指向父类，调用的就是父类的虚函数
2.父类指针或引用指向哪个子类，调用的就是子类的虚函数。

条件

1.必须通过基类的指针或者引用调用虚函数
2.被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写。

虚函数

虚函数：成员函数前面加virtual称为虚函数
注意的问题：
1.只有类的非静态成员函数可以是虚函数
2.虚函数这里virtual和虚继承中用的virtual是同一个关键字，但是他们之间没有关系。
3.子类虚函数，不写virtual，也认为他是虚函数，完成了重写。

#include<iostream>
using namespace std;
class Person {
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student :public Person
{
public:
//子类虚函数重写了父类的虚函数
	virtual void BuyTicket() { cout << "买票-半价" << endl; }
};
class Soldier :public Person
{
public:
	virtual void BuyTicket() { cout << "优先-买票" << endl; }
};

虚函数的重写

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

虚函数重写的两个例外

1.协变(基类与派生类虚函数返回值类型不同)
派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。
2. 析构函数的重写(基类与派生类析构函数的名字不同
如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。
3.子类的虚函数可以不加virtual，也算完成了重写但是父类重写的函数不加virtual就不行，因为他是这样认为的，子类是先继承父类的虚函数，继承下来以后有virtual属性了，子类只是重写这个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;
}

重载，重写，重定义的对比

重载：1.两个函数在同一作用域。
2.函数名/参数不同
重写：1.两个函数分别在基类和派生类的作用域
2.函数名/参数/返回值都必须相同
3.两个函数必须是虚函数
重定义：1.两个函数分别在基类和派生类的作用域
2.函数名相同
3.两个基类和派生类的同名函数不构成重写就是重定义。

抽象类

概念：在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。
作用:
1.可以更好的去表示现实世界中，没有实例对象对应的抽象类型。
2.体现接口继承，强制子类去重写虚函数（不重写，子类也是抽象类）要注意跟override区分，override检查子类虚函数是否完成重写。

多态的原理

虚函数表

class Base
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}
private:
	int _b = 1;
};

通过观察测试我们发现b对象是8bytes，除了_b成员，还多一个__vfptr放在对象的前面(注意有些平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。
满足多态条件以后，构成多态：
指针或引用，调用虚函数时，不是编译时确定，是运行时到指向的对象中的虚表中去找对应虚函数调用，所以指向的父类对象，调用就是父类的虚函数，指向的是子类对象，调用的就是子类的虚函数。
总结： 构成多态，指向谁调用谁的虚函数，跟对象有关。不构成多态，对象类型是什么，调用的就是哪个对象的虚函数。

动态绑定和静态绑定

1. 静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数
   重载
2. 动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用
   具体的函数，也称为动态多态。
3. 本小节之前(5.2小节)买票的汇编代码很好的解释了什么是静态(编译器)绑定和动态(运行时)绑定。
   Q：对象中虚表是在什么阶段初始化的？虚表又是在什么阶段生成的呢？
   A：在构造函数初始化列表中初始化，在编译时就生成好了。
   Q：虚函数放到虚表里面，这句话对吗？
   A：这句话不准确，虚表里面放的是虚函数地址，虚函数跟普通函数一样，编译完成后，都放在代码段。
   一个类中所有虚函数地址都会放到虚表中。

单继承和多继承关系的虚函数表

单继承的虚函数表

//基类
class Base
{
public:
	virtual void func1() { cout << "Base::func1()" << endl; }
	virtual void func2() { cout << "Base::func2()" << endl; }
private:
	int _a;
};
//派生类
class Derive : public Base
{
public:
	virtual void func1() { cout << "Derive::func1()" << endl; }
	virtual void func3() { cout << "Derive::func3()" << endl; }
	virtual void func4() { cout << "Derive::func4()" << endl; }
private:
	int _b;
};

在单继承关系中，派生类的虚表：
1.继承基类的虚表内容到派生类的虚表。
2.对派生类重写的虚函数地址进行覆盖。

多继承中的虚函数表

//基类1
class Base1
{
public:
	virtual void func1() { cout << "Base1::func1()" << endl; }
	virtual void func2() { cout << "Base1::func2()" << endl; }
private:
	int _b1;
};
//基类2
class Base2
{
public:
	virtual void func1() { cout << "Base2::func1()" << endl; }
	virtual void func2() { cout << "Base2::func2()" << endl; }
private:
	int _b2;
};
//多继承派生类
class Derive : public Base1, public Base2
{
public:
	virtual void func1() { cout << "Derive::func1()" << endl; }
	virtual void func3() { cout << "Derive::func3()" << endl; }
private:
	int _d1;
};

在多继承关系当中，派生类的虚表：
1.分别继承各个基类的虚表内容到派生类的各个虚表当中。
2.对派生类重写了的虚函数地址进行覆盖(派生类中的各个虚表中存有该被重写虚函数地址的都需要进行覆盖)，比如func1。
3.在派生类第一个继承基类部分的虚表当中新增派生类当中新的虚函数地址，比如func3。