前言：

和前面的继承一样，多态也是对类和对象的功能进行扩展，以让其更加好用的一个知识点，接下来，就让我们总结一下多态，这个依托了继承的一个重要知识点。

对多态的理解和多态的概念：

何为多态(理解多态)：

就像是某一个品牌的车，其基本的框架是相同的，但在内饰方面，会由于价格的不同而呈现出不同等级内饰，包括其他很多电子设备。车的结构都是大体相同的，但每一辆车的内饰却会因为购买者的风格和对应的价格而导致不同，此时就呈现了这一系列的车的多态。
因此，通俗的说，多态就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

多态的概念：

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。
比如某个基类和子类形成了继承关系，对于一个函数，基类和子类通过多态，就可以实现重定义这个函数，从而让基类和子类的同一个函数有不同的定义方式，调用基类时就是基类的函数调用，调用子类时就是子类的函数调用。

多态的构成条件：

以下面的代码为例子：

#include<iostream>
using namespace std;
class person
{
public:
	virtual person& getpid()//加=0就是抽象类
	{
		cout << "person()" << endl;
		return *this;
	}
	virtual void hbw()
	{
		cout<<"hbw()"<<endl;
	}
private:
	int _a;
};
class student :public person
{
	 virtual student& getpid() 
	{
		cout << "student()" << endl;
		return *this;
	}
private:
	int _a3;
 };

想要构成多态，有两个最基本的重要条件：
1. 必须通过基类的指针或者引用调用虚函数
2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写
首先先说第一点：
我们想要进行多态调用，要这样写：

student a1;
person p1;
person* p=&a1;
a1->getpid();
p=&p1;
p->getpid();

此时，我们通过p就实现了多态调用，我在这里使用的就是指针调用的方式。用引用也可以，但在这里我不演示了。
规则的第一点记住就好，要将其普通调用分开，别记混了。
下面说一说第二点，也是很关键的一点：

何为虚函数：

注意，首先强调必须是类的成员函数，被virtual修饰的类成员函数被称为虚函数。
如下：

    virtual person& getpid()//基类的虚函数
	{
		cout << "person()" << endl;
		return *this;
	}

	 virtual student& getpid() //派生类的虚函数
	{
		cout << "student()" << endl;
		return *this;
	}

这是我截取的一个父类和一个子类的虚函数，此时，这两个函数就构成了基类和子类的多态。
因此，有了多态，我们现在的调用函数的方式有两种：
1.普通调用,调用函数的类型是谁，就调用这个对象的函数
2.多态调用,调用指针或者引用对应的对象，指向父类调用父类函数，指向子类调用子类的函数

虚函数重写

何为重写：

首先我们来先说一说何为重写，这个很关键，我们要明确。
根本上就是接口继承和实现继承的区别：
普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。
虚函数的重写，重写的是函数的实现过程而非声明过程，因此子类的虚函数会继承基类的缺省参数的缺省值(因为这部分本质上还是属于声明部分而不是定义部分),而不是使用自己定义的缺省值。
我们用下面的程序来去验证这件事：

#include<iostream>
using namespace std;
class person
{
public:
	virtual person& getpid(int m=10)//加=0就是抽象类
	{
		return *this;
	}
	virtual void hbw()
	{
		cout<<"hbw()"<<endl;
	}
private:
	int _a;
};
class student :public person
{
	 virtual student& getpid(int m=100)  
	{
		cout << m << endl;
		return *this;
	}
private:
	int _a3;
 };
 int main()
{
	student s1;
	person p1;
	person* p = &s1;
	p->getpid();
	p = &p1;
	p->getpid();

	return 0;
}

打印的结果如下：

没错，正如我们所说的，它确实继承了父类的缺省值，而不是用自己的缺省值。

虚函数重写的条件！！！(这个很关键，要记好)：

1.继承关系的父子的两个虚函数，要三同(函数名相同，参数的类型对应的位置和顺序要相同，但参数的名字可以不相同，函数的返回值要相同）
2.virtual只能修饰成员函数，且这里的virtual和我们虚继承的virtual没有关系，也不是同一个virtual,只是名字恰好相同罢了
3.协变：虚函数三同的意外，它规定基类和子类虚函数的返回值可以有不同，此时会构成协变，但这个返回值必须是父子类的指针或者引用(这个父类和子类不一定非要是自己的，用其他的父类和子类的指针和引用也是可以的）
4.派生类重写的虚函数，函数是可以不用加virtual的(但建议加上，这一点效率还是不需要节省的),但父类是必须加上virtual的

析构函数的多态(本质上也属于虚函数重写的一种例外)：

在继承章节中，我们曾在析构那里说到，继承的子类和父类的析构被统一处理成一个名字destructor，至于为什么处理成同一个名字，我想今天有了多态，我们就可以知道为什么了，理由如下：
如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。

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

此时，根据虚函数重写的第4点，我们就可以在派生类的析构函数中不加virtual，同时由于他们的析构函数被处理成了同一个名字，且派生类的析构实现了对基类析构函数的重写，因此此时的析构函数就构成了多态，这才有了可以在派生类的析构里同时也可以调用基类的析构的原因。

C++ 11的两个关键字 override 和final:

从上面可以看出，C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名字母次序写反而无法构成重载,让虚函数成了普通的函数，但是用户很难观察到这个问题，这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失，因此：C++11提供了override和final两个关键字，可以帮助用户检测是否重写。减轻了用户的调试负担。

final:

final用来修饰虚函数，让其不能被重写。
如下：

#include<iostream>
using namespace std;
class person
{
public:
	virtual person& getpid(int m=10) final//加=0就是抽象类
	{
		return *this;
	}
	virtual void hbw()
	{
		cout<<"hbw()"<<endl;
	}
private:
	int _a;
};
class student :public person
{
	 virtual student& getpid(int m=100) override 
	{
		cout << m << endl;
		return *this;
	}
private:
	int _a3;
 };

加上这一条后，报错情况如下：

这里强调一下final的使用细节，它是在使用了final的之后的这个虚函数就不能再被重写了，而final修饰的虚函数在final之前的重写无影响。

#include<iostream>
using namespace std;
class person
{
public:
	virtual person& getpid(int m=10) //加=0就是抽象类
	{
		return *this;
	}
	virtual void hbw()
	{
		cout<<"hbw()"<<endl;
	}
private:
	int _a;
};
class student :public person
{
	 virtual student& getpid(int m=100) final
	{
		cout << m << endl;
		return *this;
	}
private:
	int _a3;
 };
class hbw :public student
{
	virtual hbw& getpid(int m=30) 
	{
		cout << "hbw" << endl;
		return *this;
	}
};

如上面的代码，报错情况如下：

这正好验证了我的使用细节。

override:

用来检查派生类的虚函数是否重写了基类某个虚函数，如果没有重写则编译报错。
如下：

#include<iostream>
using namespace std;
class person
{
public:
	 person& getpid(int m=10) //加=0就是抽象类
	{
		return *this;
	}
	virtual void hbw()
	{
		cout<<"hbw()"<<endl;
	}
private:
	int _a;
};
class student :public person
{
	 virtual person& getpid(int m=10) override
	{
		return *this;
	}
private:
	int _a3;
 };

遇到这样的代码，编译器就会直接报错，如下：

抽象类：

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

#include<iostream>
using namespace std;
class person
{
public:
	 virtual person& getpid(int m=10)=0 //加=0就是抽象类
	{
		return *this;
	}
	virtual void hbw()
	{
		cout<<"hbw()"<<endl;
	}
private:
	int _a;
};
class student :public person
{
	 virtual person& getpid(int m=10) 
	{
		return *this;
	}
private:
	int _a3;
 };
 int main()
 {
    person b;
	student s;
	return 0;
 }

报错如下：

使用了抽象类，可以强制派生类虚函数必须重写才能实例化出对象，否则也没法实例化，但是这个用于基类不使用只使用派生类的情况，但大多数情况下基类还是需要使用实例化的。

重载，重写(覆盖),隐藏(重定义)的对比:

到目前为止，我们已经学习了三个相近的概念：函数重载，虚函数重写，函数隐藏
这三者的关系用下面的一张图表示就是：

我的总结就是：
首先先看作用域，在同一个作用域里面的就是重载，反之就是重写和隐藏中的一种，之后再根据重写的条件判断是否构成了重写，倘若不是就是隐藏。
例子如下：

#include<iostream>
using namespace std;
class person
{
public:
	 virtual person& getpid(int m=10)//加=0就是抽象类
	{
		return *this;
	}
	virtual void hbw()
	{
		cout<<"hbw()"<<endl;
	}

	void hbw(int a = 32)
	{
		cout << "hbw()->" << endl;
	}
	void print()
	{
		cout << "person()" << endl;
	}
private:
	int _a;
};
class student :public person
{
	 virtual person& getpid(int m=10) 
	{
		return *this;
	}
	 void print()
	 {
		 cout << "student()" << endl;
	 }
private:
	int _a3;
 };

在这个代码里，此时我们就说，hbw两个函数在person作用域里，因此他们构成了重载，而getpid在父类和派生类中构成了虚函数重写，print函数则在基类和派生类里构成了隐藏。

多态的实现原理：

在调试一个带有虚函数的类的时候，我发现了这样的情况：

在类的内部存在一个_vfptr,点开它，你会发现它是一个数组，存储着函数的指针，而对应的函数指针正是虚函数的指针，这便是虚函数表的指针。

虚函数表：

一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。
虚函数表的本质就是一个数组元素为函数指针的数组，里面的每一个元素都存储着虚函数的地址，一般在这个虚函数表的最后都要放置一个nullptr作为结尾，故被称为虚函数表，而我们的含有虚函数的类里就有这样的一个虚函数表指针，用来方便去访问虚函数表。即为_vfptr.

我们用下面的代码来总结一下虚函数表的一些规则：

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

通过观察和测试，我们发现了以下几点问题：
1. 派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员，虚表指针也就是存在部分的另一部分是自己的成员。
3. 基类b对象和派生类d对象虚表是不一样的，这里我们发现Func1完成了重写，所以d的虚表中存的是重写的Derive::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。
4. 另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函数，所以不会放进虚表。
5. 虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr。
6. 总结一下派生类的虚表生成：a.先将基类中的虚表内容拷贝一份到派生类虚表中 b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数 c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。
这最后一条高度概括了虚函数的原理，即是通过虚表来存储虚函数，派生类重写的虚函数，则覆盖之前的虚函数数据，额外利用新的空间和地址来存储重写的函数，反之，倘若没有重写，则正常去使用从基类继承的虚函数表即可。
那么，多态的原理和虚函数表有什么关系呢？

多态的原理：

class Person {
public:
 virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
 virtual void BuyTicket() { cout << "买票-半价" << endl; }
};
void Func(Person& p) {p.BuyTicket();
}
int main()
{
Person Mike;
 Func(Mike);
Student Johnson;
Func(Johnson);
 mike.BuyTicket();
 return 0; }

我们通过这个代码来探究一下多态的实现方式，

void Func(Person* p) 
{
...
 p->BuyTicket();
// p中存的是mike对象的指针，将p移动到eax中
001940DE  mov         eax,dword ptr [p]
// [eax]就是取eax值指向的内容，这里相当于把mike对象头4个字节(虚表指针)移动到了edx
001940E1  mov         edx,dword ptr [eax]
// [edx]就是取edx值指向的内容，这里相当于把虚表中的头4字节存的虚函数指针移动到了eax
00B823EE  mov         eax,dword ptr [edx]
// call eax中存虚函数的指针。这里可以看出满足多态的调用，不是在编译时确定的，是运行起来
以后到对象的中取找的。
001940EA  call        eax  
00头1940EC  cmp         esi,esp  
}
int main()
{
// 首先BuyTicket虽然是虚函数，但是mike是对象，不满足多态的条件，所以这里是普通函数的调
用转换成地址时，是在编译时已经从符号表确认了函数的地址，直接call 地址
 mike.BuyTicket();
00195182  lea         ecx,[mike]
00195185  call        Person::BuyTicket (01914F6h)  
}

原理如下：
1. 观察下图的红色箭头我们看到，p是指向mike对象时，p->BuyTicket在mike的虚表中找到虚函数是Person::BuyTicket。
2. 观察下图的蓝色箭头我们看到，p是指向johnson对象时，p->BuyTicket在johson的虚表中找到虚函数是Student::BuyTicket。
3. 这样就实现出了不同对象去完成同一行为时，展现出不同的形态。
4. 反过来思考我们要达到多态，有两个条件，一个是虚函数覆盖，一个是对象的指针或引用调用虚函数。反思一下为什么？
5. 再通过上面的汇编代码分析，看出满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象的虚函数表中去找的。不满足普通的函数调用时编译时确认好的。

虚函数表 虚函数的位置：

首先虚函数的位置不必多说，一定是和普通函数一样都存在于代码段，然后通过虚函数表里的地址去公共访问。
那虚函数表放在哪里呢？
下面让我们探究一下：

#include<iostream>
using namespace std;
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;
};
int main()
{
	Base b1;
	Base b2;
	static int a = 10;
	int b = 32;
	int* p = new int;
	const char* m = "hello world!";
	printf("静态区：%p\n", &a);
	printf("栈：%p\n", &b);
	printf("堆：%p\n", p);
	printf("常量代码段：%p\n", m);
	printf("虚函数表：%p\n",  *((int*)&b1));
	printf("虚函数：%p\n", &Base::func1);//可别写成b1.func1，要知道函数的地址是不在特定的对象里面的，但是它在类的类作用域里面,故我们不能用对象去取，要用类域去取，同时成员函数取地址要加&符号，这是规定
	printf("普通函数：%p\n",com);//注意，类里面的函数用访问限定符访问，普通函数则直接访问即可
}

我们用这个程序来看看虚函数表存在哪里？结果如下：

是的，根据结果，虚函数表正是存在于代码段，和虚函数在一起，而不是在栈区或者静态区，这是一个出乎意料的结果。

单继承的虚函数表：

我们用这个代码来探究单继承的虚函数表：

#include<iostream>
using namespace std;
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;
};
class X :public Derive
{
public:
	virtual void func3()
	{
		cout << "X::func3" << endl;
	}
};
void com()//普通函数
{
	cout << "hbw" << endl;
}
typedef void(*VFUNC)();//函数指针变量的typedef 
void PrintVFT(VFUNC*a)//打印虚表
{
	int i = 0;
	for (i = 0; a[i] != 0; i++)//虚函数表的最后一个元素会自动添加一个0，以示末尾
	{
		printf("[%d]:%p->", i, a[i]);
		VFUNC f = a[i];//取得地址，然后对对应的函数进行打印进行检验
		f();
	}
	printf("\n");
}
int main()
{
	Base b;
	Derive d;
	X x;
	PrintVFT((VFUNC*)(*(int*)&b));//注意这里要进行一次强转，使其符合函数的参数的指针类型
	PrintVFT((VFUNC*)(*(int*)&x));//注意这里要进行一次强转，使其符合函数的参数的指针类型
	PrintVFT((VFUNC*)(*(int*)&d));//注意这里要进行一次强转，使其符合函数的参数的指针类型
	return 0;
}

由于通过监视窗口，我们没法看到全部的虚函数，因此，利用这个虚函数表，我们来探究一下单继承中虚函数是如何存储在虚函数表中的。
结果如下：

由此，我们可以这样总结单继承虚函数的特点：
单继承每一个对象都只有一张虚表，重写就覆盖，不重写就继承。

多继承的虚函数表：

验证代码如下：

class Base1 
{
public:
	virtual void func1() 
	{ 
		cout << "Base1::func1" << endl; 
	}
	virtual void func2() 
	{ 
		cout << "Base1::func2" << endl; 
	}
private:
	int b1;
};
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; 
	}
	virtual void hbw()
	{
		cout << "Derive::hbw" << endl;
	}
private:
	int d1;
};
typedef void(*VFUNC)();//函数指针变量的typedef 
void PrintVFT(VFUNC*a)//打印虚表
{
	int i = 0;
	for (i = 0; a[i] != 0; i++)//虚函数表的最后一个元素会自动添加一个0，以示末尾
	{
		printf("[%d]:%p->", i, a[i]);
		VFUNC f = a[i];//取得地址，然后对对应的函数进行打印进行检验
		f();
	}
	printf("\n");
}
int main()
{
	Base1 b;
    Derive d;
    PrintVFT((VFUNC*)(*(int*)&d));//注意这里要进行一次强转，使其符合函数的参数的指针类型
   Base2* tmp = &d;
   PrintVFT((VFUNC*)(*(int*)tmp));
    return 0;
}

其结果如下：

由多继承的结果我们可以总结：
继承了几个有虚函数的父类，就有多少张虚表，而自己的成员函数向第一张虚表里面放

菱形虚拟继承的虚函数表：

实际中我们不建议设计出菱形继承及菱形虚拟继承，一方面太复杂容易出问题，另一方面这样的模型，访问基类成员有一定得性能损耗。所以菱形继承、菱形虚拟继承我们的虚表我们就不看了，一般我们也不需要研究清楚，因为实际中很少用。
不过，在这里，依然是要区分好虚函数表和虚基表，他们分别代表了虚拟继承和虚函数多态，别搞混！！！

补充问题：
为何派生类重写的两个父类中都有一个重写的函数，但地址却不同？
出现这个现象是因为切片导致指针的位置发生改变，但想访问一个类的成员，应当从这个类的头的地址开始，故这里会有一个地址移动到对象开头的过程使其成为整个对象的指针后再去访问的过程，所以这里的母的是为了修正this指针，让其指向类对象，因此我们重写的两个函数的地址不同。

多态的一些问题总结：

1. 什么是多态？答：根据前面的定义
2. 什么是重载、重写(覆盖)、重定义(隐藏)？答：根据前面的讲解
3. 多态的实现原理？答：虚函数表的使用，根据前面的定义即可
4. inline函数可以是虚函数吗？答：可以，不过编译器就忽略inline属性，这个函数就不再是
   inline，因为虚函数要放到虚表中去。而内联函数没有地址，会直接展开，所以这里体现了其两种功能，构成了多态，此函数就没有了内联属性，有内联就证明派生类没有重写，不是多态
5. 静态成员可以是虚函数吗？答：不能，因为静态成员函数没有this指针，这是关键，使用类型::成员函数
   的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。
6. 构造函数可以是虚函数吗？答：不能，因为对象中的虚函数表指针是在构造函数初始化列表
   阶段才初始化的。
7. 析构函数可以是虚函数吗？什么场景下析构函数是虚函数？答：可以，并且最好把基类的析
   构函数定义成虚函数。在继承的父子类场景下，子类自动调用父类的析构，这便是虚函数
8. 对象访问普通函数快还是虚函数更快？答：首先如果是普通对象，是一样快的。如果是指针
   对象或者是引用对象，则调用的普通函数快，因为构成多态，运行时调用虚函数需要到虚函
   数表中去查找。
9. 虚函数表是在什么阶段生成的，存在哪的？答：虚函数表是在编译阶段就生成的，一般情况
   下存在代码段(常量区)的。
10. C++菱形继承的问题？虚拟继承的原理？答：根据菱形继承的定义去回答即可。注意这里不要把虚函数表和虚基
    表搞混了，虚拟继承利用了虚基表，而虚函数利用了虚函数表
11. 什么是抽象类？抽象类的作用？答：父类加=0，不可实例化即为抽象类。抽象类强制重写了虚函数，另外抽
    象类体现出了接口继承关系，也就是声明是继承继承下来的，包括对应的缺省值参数的缺省值也是继承下来的，而不是用自己的，只有函数的定义才是派生类重写的

总结：

我们本次系统的总结了一下多态的知识，不过在我看来我本篇的描述并不清晰，可以说是着急赶工而没有对很多问题深挖，如果有时间我会重新写这篇文章，但现在这仅代表我目前的理解，还希望这篇文章能让我理清多态的知识，也对其他人有所帮助。