1、概念

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

2、定义

2.1多态构成的条件

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

2.2虚函数

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

class A {
	virtual void func(){}
};

2.3虚函数的重写

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

class A 
{
public:
 	virtual void func() { cout << "A::func()" << endl; }
};
class B : public A 
{
public:
 	virtual void func() { cout << "B::func()" << endl; }
 }
void Test(A& p){ p.func(); }
int main() {
	A a;
	B b;
	Test(a);
	Test(b);
	return 0;
}

测试结果为


值得注意的是Test函数传的是引用，其实指针也是可以的，但是如果直接传对象，会进行拷贝构造，对于派生类来说也调用了基类的函数。

在下面两种情况下也是虚函数的重写：

1.协变(基类与派生类虚函数返回值类型不同)

当满足虚函数重写的条件但函数返回值类型不同时，即基类虚函数返回基类对象的指针或者引

用，派生类虚函数返回派生类对象的指针或者引用时，也可构成重写，这种情况称为协变。

2.析构函数的重写

如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然函数名不相同，但编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。

override 和 final关键字

final：修饰虚函数，表示该虚函数不能再被继承。例：

class A {
public:
	 virtual void func() final {}
};
class B :public A {
public:
	 virtual void func() {}//这里语法会出现错误
};

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

class A {
public:
	virtual void func() {}
};
class B : public A {
public:
	virtual void func() override{}//派生类中重写基类的函数错误时，会报错
};

3、抽象类

3.1概念

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。如：

class A {
public:
	virtual void func()=0;
};
class B : public A {
public:
 	virtual void func() { cout << "B::func()" << endl; }//重写上面的纯虚函数
 }
int main() {
	A a;
	B b;
	return 0;
}

3.2 接口继承和实现继承

普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。

4、多态的原理

4.1虚函数表

class A {
public:
	 virtual void Func() {
	 	cout << "Func()" << endl;
	 }
private:
	int _a = 10;
 };
int main() {
	A a;
	return 0;
}

在vs32位平台下调试会发现对象a的内存中有一个_vfptr指针，计算a的大小时会发现其并不是仅仅有_a所占的8字节，而是16字节，这里就包括了这个指针，该指针称为虚函数表指针(v代表virtual，f代表function)，一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。

现在，为A增加一个虚函数和一个普通函数，用另一个对象B去继承A，且重写A的func函数时，调试查看结果，代码及结果如下：

class A {
public:
	virtual void Func1() {cout << "A::Func1()"<< endl;}
 	virtual void Func2(){cout << "Base::Func2()" << endl;}
 	void Func3() {cout << "Base::Func3()" << endl;}
private:
	int _a = 1;
};
class B : public A {
public:
	virtual void Func1() {cout << "B::Func1()" << endl;}//重写
private:
	int _b = 2;
};
int main()
{
	 A a;
	 B b;
	 return 0;
}

1. 派生类对象b中也有一个虚表指针，b对象由两部分构成，一部分是父类继承下来的成员，虚表指针是派生类对象自己的成员。
2. 基类a对象和派生类b对象虚表是不一样的，这里我们发现Func1完成了重写，所以b的虚表中存的是重
   
   写的B::Func1()，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。
3. 另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函数，所以不会
   
   放进虚表。
4. 虚函数表本质是一个存虚函数指针的指针数组，这个数组最后面放了一个nullptr。
5. 总结一下派生类的虚表生成：1、先将基类中的虚表内容拷贝一份到派生类虚表中 2、如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数 3、派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。4、多继承时，子类自己的虚函数只会放到第一个父类的虚表后面，其他父类的虚表不需要存储，因为存储了也不能调用。5、虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是他的指针又存到了虚表中。

4.2多态的原理

既然对象实现多态时出现了虚表指针，那么多态的原理也就跟此有关了。当用基类的指针或者引用去调用虚函数时，指针指向的虚表指针不同，这就导致其调用的函数不同，这样就实现出了不同对象去完成同一行为时，展现出不同的形态。

4.3 动态绑定与静态绑定

1. 静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载
2. 动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。