支付宝扫码领红包，有的人扫红包可以得到8块、10块......而有的人扫红包却只能得到几毛......。这背后其实也是一个多态行为。（PS：瞎编，仅供娱乐）支付宝首先会分析你的账户数据，比如你是新用户/没有经常支付宝支付等，那么你就需要被鼓励使用支付宝，那么你的扫码金额=random()%99；比如你经常使用支付宝支付/支付宝账户常年没钱，那么你就不需要太被鼓励去使用支付宝，那么你的扫码金额=random()%1；同样是扫码动作，不同的用户扫码得到的不一样的红包，这也是一种多态行为。

2. 多态的定义及实现

2.1 多态的构成条件

多态是在不同继承关系的类对象，去调用同一函数，产生不同的行为。

继承中要构成多态条件：

必须通过基类的指针或者引用调用虚函数

被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

2.2 虚函数重写

虚函数重写/覆盖条件：虚函数(只有成员函数才能加virtual)+三同（函数名、参数、返回值）

不符合重写，就是隐藏关系。

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

虚函数重写的例外（C++挖的坑）：

子类虚函数不加virtual，依旧构成重写。（先继承下虚函数，再重写（实现））

协变（基类与派生类虚函数返回值类型不同）

派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用，称为协变。

析构函数的重写（基类与派生类析构函数的名字不同）

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

2.3 C++11 override和final

C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失，因此：

C++11提供了override和fifinal两个关键字，可以帮助用户检测是否重写。

final：修饰虚函数，表示该虚函数不能再被重写

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

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

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

2.4 重载、覆盖（重写）、隐藏（重定义）的对比

3. 抽象类

3.1 概念

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口

类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生

类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

class Car
{
public:
virtual void Drive() = 0;
};

3.2 接口继承和实现继承

普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实

现。

虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成

多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。

我们来做道面试题看看接口继承：
   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: A->0 B: B->1 C: A->1 D: B->0 E: 编译出错 F: 以上都不正确

答案：B

解析：虚函数重写是接口继承，重写实现，继承接口。

上例中，接口继承上面的void func(int val=1)。调用test，B*传递给A*（切片操作）但是this还是指向B对象，this->调用的是指向对象的函数。（多态）

多态指向谁调用谁！

4. 多态的原理

4.1 虚函数表

虚函数表的实质是函数指针数组

// 这里常考一道笔试题：sizeof(Base)是多少？
class Base
{
public:
 virtual void Func1()
 {
 cout << "Func1()" << endl;
 }
private:
 int _b = 1;
};

通过观察测试我们发现b对象是8bytes，除了_b成员，还多了一个__vfptr放在对象前面（VS平台），对象中的指针（Vs x86,指针4bytes）我们叫做虚函数表指针。一个含有虚函数表的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也称虚表。

注意： 虚函数存在哪的？虚表存在哪的？

虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。在VS下测验发现虚表存在代码段。

4.2 多态的原理

举个模型来演示下：

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

	virtual void Func() { cout << "Func" << endl; }


	int _a = 0;
};

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

	int _b = 0;
};

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

int main()
{
	Person Mike;
	Func(Mike);

	Student Johnson;
	Func(Johnson);

	return 0;
}

总结：

多态的本质原理，符合多态的两个条件。那么调用时，会到指向对象的虚表中找到对应的虚函数地址，进行调用。

多态（程序运行时去指向对象的虚表中找到函数地址，进行调用，所以p指向谁调用谁的虚函数）

普通函数调用，编译链接时确定函数的地址,运行时直接调用。类型是谁调用谁的。

4.3 动态绑定与静态绑定

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

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

5.1 单继承中的虚函数表

结论：

单继承：同一个类的对象共用一个虚表
vs下，不管是否完成重写，子类虚表跟父类虚表都不是同一个（内容改变）
子类虚表里有自己的和父类的虚函数（存的是虚函数指针）

测验下子类自己的虚函数是放在子类的虚表还是父类的虚表：

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

嘿，神奇了，这里子类的func3和func4都不见了，是真的不见了吗？其实不是！这里是vs编译器的监视窗口故意隐藏了这两个函数，可认为这是一个bug。那么我们如何查看d的虚表呢，我们使用下列代码打印出虚表中的函数。

typedef void(*VFPTR)();
void PrintVFTable(VFPTR* table)
{
	for (size_t i = 0; table[i] != nullptr; ++i)
	{
		printf("vft[%d]:%p->", i, table[i]);
		VFPTR pf = table[i];
		pf();
	}
	cout << endl;
}

结果我们可以看到，子类的虚函数确实放在子类自己的虚表当中。

5.2 多继承中的虚函数表