面向对象三大特性之多态

多态

什么是多态？

多态就是函数调用的多种形态，使用多态能够使得不同对象去完成同一件事，产生不同的动作和结果。

例如，在现实生活中普通人买票是全价，学生买票是半价，而军人允许有先买票。不同身份的人去买票，产生的行为是不同的，这就是都多态。

多态的分类

在C++中，多态的实现和**联编（也称绑定）**这一概念有关。一个源程序经过编译、链接，成为可执行文件的过程是把可执行代码联编（或称装配）在一起的过程。其中在运行之前就完成的联编成为静态联编（前期联编）；而在程序运行之时才完成的联编叫动态联编（后期联编）。

静态多态

在程序设计时，经常会用到多态。

静态联编支持的多态性称为编译时多态性（静态多态）。在C++中，编译时多态是通过函数重载和模板实现的。利用函数重载机制，在调用同名函数时，编译系统会根据实参的具体情况确定索要调用的是哪个函数。

 int i;char ch;cin >> i;cin >> ch;cout << i << endl;cout << ch << endl;int i = 0, j = 1;double d = 1.1, e = 2.2;swap(i, j);swap(d, e);

动态多态

动态联编所支持的多态性称为运行时多态（动态多态）。在C++中，运行时多态是通过虚函数来实现的。

多态的定义和实现

多态的构成条件

多态是指不同的继承关系的类对象，去调用同一函数，产生不同的行为。在继承中要想构成多态需要满足下面两个条件：

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

虚函数

被virtual修饰的类成员函数。

class Person
{
public://被virtual修饰的类成员函数virtual void BuyTicket(){cout << "买票-全价" << endl;}
};

需要注意的是：

只有类的非静态成员函数前才可以加virtual，普通函数前不能加virtual。
虚函数这里的virtual和虚继承中的virtual是同一个关键字，但是它们之间没有任何关系。虚函数这里的virtual是为了实现多态，而虚继承的virtual是为了解决菱形继承的数据冗余和二义性。

虚函数的重写

虚函数的重写也叫做虚函数的覆盖，若派生类中有一个和基类完全相同的虚函数(返回值类型相同、函数名相同以及参数列表完全相同)，此时我们称该派生类的虚函数重写了基类的虚函数。

例如，我们以下Student和Soldier两个子类重写了父类Person的虚函数：

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

现在我们可以通过基类Person的指针或者引用调用虚函数buyTicket，此时不同类型的对象，调用的就是不同的函数，产生的也是不同的结果，进而实现了函数调用的都种形态。

void Func(Person& p)
{//通过父类的引用调用虚函数p.BuyTicket();
}
void Func(Person* p)
{//通过父类的指针调用虚函数p->BuyTicket();
}
int main()
{Person p;   //普通人Student st; //学生Soldier sd; //军人Func(p);  //买票-全价Func(st); //买票-半价Func(sd); //优先买票Func(&p);  //买票-全价Func(&st); //买票-半价Func(&sd); //优先买票return 0;
}

**注意：**在重写基类虚函数时，派生类的虚函数不加virtual关键字也可以构成重写，主要原因是因为继承后基类的虚函数被继承下来了，在派生类中依旧保持虚函数属性。但是这种写法不是很规范，因此建议在派生类的虚函数前也加上virtual关键字。

虚函数重写的例外

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

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

例如，下列代码中基类Person当中的虚函数fun的返回值类型是基类A对象的指针，派生类Student当中的虚函数fun的返回值类型是派生类B对象的指针，此时也认为派生类Student的虚函数重写了基类Person的虚函数。
```
//基类
class A
{};
//子类
class B : public A
{};
//基类
class Person
{
public://返回基类A的指针virtual A* fun(){cout << "A* Person::f()" << endl;return new A;}
};
//子类
class Student : public Person
{
public://返回子类B的指针virtual B* fun(){cout << "B* Student::f()" << endl;return new B;}
};
```
此时，我们通过父类Person的指针调用虚函数fun，父类指针若指向的是父类对象，则调用父类的虚函数，父类指针若指向的是子类对象，则调用子类的虚函数。
```
int main()
{Person p;Student st;//父类指针指向父类对象Person* ptr1 = &p;//父类指针指向子类对象Person* ptr2 = &st;//父类指针ptr1指向的p是父类对象，调用父类的虚函数ptr1->fun(); //A* Person::f()//父类指针ptr2指向的st是子类对象，调用子类的虚函数ptr2->fun(); //B* Student::f()return 0;
}
```
析构函数的重写（基类与派生类的析构函数的名字不同）

如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加关键字virtual，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。

例如，下面代码中父类Person和子类Student的析构函数构成重写：
```
//父类
class Person
{
public:virtual ~Person(){cout << "~Person()" << endl;}
};
//子类
class Student : public Person
{
public:virtual ~Student(){cout << "~Student()" << endl;}
};
```
那父类和子类的析构函数构成重写的意义何在呢？试想以下场景：分别new一个父类对象和子类对象，并均用父类指针指向它们，然后分别用delete调用析构函数并释放对象空间。
```
int main()
{//分别new一个父类对象和子类对象，并均用父类指针指向它们Person* p1 = new Person;Person* p2 = new Student;//使用delete调用析构函数并释放对象空间delete p1;delete p2;return 0;
}
```
在这种场景下，若是父类和子类的析构函数没有构成重写就可能会导致内存泄漏，因为此时delete p1和delete p2都是调用的父类的析构函数，而我们所期望的是p1调用父类的析构函数，p2调用子类的析构函数，即我们期望的是一种多态行为。
此时只有父类和子类的析构函数构成了重写，才能使得delete按照我们的预期进行析构函数的调用，才能实现多态。因此，为了避免出现这种情况，比较建议将父类的析构函数定义为虚函数。

在继承当中，子类和的析构函数和父类的析构函数构成隐藏的原因就在这里，这里表面上看子类的析构函数和父类的析构函数的函数名不同，违背了重写的规则，其实不然，编译器为了构成重写，编译后析构函数的名字会被统一处理成destructor()。这也说明基类的析构函数最好写成虚函数。

C++11 关键字override 和 final

从上面可以看出，C++对函数重写的要求比较严格，有些情况下由于疏忽可能会导致函数名的字母次序写反而无法构成重写，而这种错误在编译期间是不会报错的，直到在程序运行时没有得到预期结果再来进行调试会得不偿失，因此，C++11提供了final和override两个关键字，可以帮助用户检测是否重写。

override：检查派生类虚函数是否重写与基类相对应的虚函数，如果没有完成重写则报错

例如，子类Student和Soldier的虚函数BuyTicket被override修饰，编译时就会检查子类的这两个BuyTicket函数是否重写了父类的虚函数，如果没有则会编译报错。

//父类
class Person
{
public:virtual void BuyTicket(){cout << "买票-全价" << endl;}
};
//子类
class Student : public Person
{
public://子类完成了父类虚函数的重写，编译通过virtual void BuyTicket() override{cout << "买票-半价" << endl;}
};
//子类
class Soldier : public Person
{
public://子类没有完成了父类虚函数的重写，编译报错virtual void BuyTicket(int i) override{cout << "优先-买票" << endl;}
};

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

例如，父类Person的虚函数BuyTicket被final修饰后就不能再被重写了，子类若是重写了父类的BuyTicket函数则编译报错。

//父类
class Person
{
public://被final修饰，该虚函数不能再被重写virtual void BuyTicket() final{cout << "买票-全价" << endl;}
};
//子类
class Student : public Person
{
public://重写，编译报错virtual void BuyTicket(){cout << "买票-半价" << endl;}
};
//子类
class Soldier : public Person
{
public://重写，编译报错virtual void BuyTicket(){cout << "优先-买票" << endl;}
};

重载、重写（覆盖）、重定义（隐藏）

抽象类

什么是抽象类

在虚函数的后面写上=0，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。

#include <iostream>
using namespace std;
//抽象类（接口类）
class Car
{
public://纯虚函数virtual void Drive() = 0;
};
int main()
{Car c; //抽象类不能实例化出对象，errorreturn 0;
}

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

#include <iostream>
using namespace std;
//抽象类（接口类）
class Car
{
public://纯虚函数virtual void Drive() = 0;
};
//派生类
class Benz : public Car
{
public://重写纯虚函数virtual void Drive(){cout << "Benz-舒适" << endl;}
};
//派生类
class BMV : public Car
{
public://重写纯虚函数virtual void Drive(){cout << "BMV-操控" << endl;}
};
int main()
{//派生类重写了纯虚函数，可以实例化出对象Benz b1;BMV b2;//不同对象用基类指针调用Drive函数，完成不同的行为Car* p1 = &b1;Car* p2 = &b2;p1->Drive();  //Benz-舒适p2->Drive();  //BMV-操控return 0;
}

抽象类既然不能实例化对象，那么抽象类存在的意义是什么？

抽象类可以更好地去表示现实世界中，没有具体对象对应的抽象类型，比如：植物、动物、汽车。

抽象类很好的体现了虚函数的继承是一种接口继承，强制派生类去实现纯虚函数的重写，因为派生类若是没有重写从基类继承的纯虚函数，那么派生类也是抽象类，无法实例化出对象。

接口继承和实现继承

**实现继承：**普通函数的继承是一种实现继承，派生类继承了基类，则派生类可以使用基类的成员函数。

**接口继承：**虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，其目的是为了重写虚函数，完成不同的结果，达成多态。

**建议:**如果不实现多态，就不要把函数定义为虚函数。

多态的原理

虚函数表

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

对于上面的Base类，它的大小为多少？

通过观察，我们可以发现：

int main()
{Base b;cout << sizeof(b) << endl; // 12return 0;
}

b对象当中除了_b、_ch成员外，实际上还有一个_vfptr放在对象的前面（有些平台可能会放到对象的最后面，这个跟平台有关）。

对象中的这个指针叫做虚函数表指针，简称虚表指针。足校指针指向一个虚函数表，简称虚表。每一个含有虚函数的类中都至少有一个虚表指针。

虚函数表中到底放的是什么？

在下面Base类中有三个成员函数，其中Func1和Func2是虚函数，Func3是普通的成员函数，Derive类仅对Func1进行了重写。

#include <iostream>
using namespace std;
//父类
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://重写虚函数Func1virtual void Func1(){cout << "Derive::Func1()" << endl;}
private:int _d = 2;
};
int main()
{Base b;Derive d;return 0;
}

通过调试可以发现，基类对象b和派生类对象d当中除了自己的成员变量外，基类和派生类对象都有一个虚表指针，分别指向自己的虚表。

实际上虚表当中存储的就是虚函数的地址，因为父类当中的Func1和Func2都是虚函数，所以父类对象b的虚表当中存储的就是虚函数Func1和Func2的地址。

而子类虽然继承了父类的虚函数Func1和Func2，但是子类对父类的虚函数Func1进行了重写，因此，子类对象d的虚表当中存储的是父类的虚函数Func2的地址和重写的Func1的地址。这就是为什么虚函数的重写也叫做覆盖，覆盖就是指虚表中虚函数地址的覆盖，重写是语法层的概念，覆盖是原理实现层的概念。

其次需要注意的是：Func2是虚函数，所以继承下来后放进了子类的虚表，而Func3是普通成员函数，继承下来后不会放进子类的虚表。此外，虚函数表本质是一个存虚函数指针的指针数组，一般情况下会在这个数组最后放一个nullptr。

总结一下，派生类的虚表生成步骤如下：

先将基类中的虚表内容拷贝一份到派生类的虚表。

如果派生类重写了基类中的某个虚函数，则用派生类自己的虚函数地址覆盖虚表中基类的虚函数地址。

派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。

虚表是什么阶段初始化的？虚函数存在哪里？虚表存在哪里？

虚表实际上是在构造函数初始化列表阶段进行初始化的，注意虚表当中存的是虚函数的地址不是虚函数，虚函数和普通函数一样，都是存在代码段的，只是它的地址又存到了虚表当中。另外，对象中存的不是虚表而是指向虚表的指针。
至于虚表是存在哪里的，我们可以通过以下这段代码进行判断。

int j = 0;
int main()
{Base b;Base* p = &b;printf("vfptr:%p\n", *((int*)p)); //000FDCACint i = 0;printf("栈上地址:%p\n", &i);       //005CFE24printf("数据段地址:%p\n", &j);     //0010038Cint* k = new int;printf("堆上地址:%p\n", k);       //00A6CA00char* cp = "hello world";printf("代码段地址:%p\n", cp);    //000FDCB4return 0;
}

代码当中打印了对象b当中的虚表指针，也就是虚表的地址，可以发现虚表地址与代码段的地址非常接近，由此我们可以得出虚表实际上是存在代码段的。

多态的原理

例如，下面代码中，为什么当父类Person指针指向的是父类对象Mike时，调用的就是父类的BuyTicket，当父类Person指针指向的是子类对象Johnson时，调用的就是子类的BuyTicket?

#include <iostream>
using namespace std;
//父类
class Person
{
public:virtual void BuyTicket(){cout << "买票-全价" << endl;}int _p = 1;
};
//子类
class Student : public Person
{
public:virtual void BuyTicket(){cout << "买票-半价" << endl;}int _s = 2;
};
int main()
{Person Mike;Student Johnson;Johnson._p = 3; //以便观察是否完成切片Person* p1 = &Mike;Person* p2 = &Johnson;p1->BuyTicket(); //买票-全价p2->BuyTicket(); //买票-半价return 0;
}

通过调试可以发现，对象Mike中包含一个成员变量_p和一个虚表指针，对象Johnson中包含两个成员变量_p和_s以及一个虚表指针，这两个对象当中的虚表指针分别指向自己的虚表。

围绕此图分析便可得到多态的原理：

父类指针p1指向Mike对象，p1->BuyTicket在Mike的虚表中找到的虚函数就是Person::BuyTicket。
父类指针p2指向Johnson对象，p2->BuyTicket在Johnson的虚表中找到的虚函数就是Student::BuyTicket。

这样就实现出了不同对象去完成同一行为时，展现出不同的形态。

多态构成的两个条件：

一是完成虚函数的重写；

二是必须使用父类的指针或者引用去调用虚函数。

必须完成虚函数的重写是因为我们需要完成子类虚表当中虚函数地址的覆盖，那为什么必须使用父类的指针或者引用去调用虚函数呢？为什么使用父类对象去调用虚函数达不到多态的效果呢？

Person* p1 = &Mike;
Person* p2 = &Johnson;

在学习C++继承时，使用父类指针或者引用时，实际上是一种切片行为，切片时只会让父类指针或者引用得到父类对象或子类对象中切出来的那一部分。

由此可见，我们使用p1和p2去调用虚函数时，p1和p2通过虚表指针找到的虚表不一样，所以最终调用的函数也不一样。

Person p1 = Mike;
Person p2 = Johnson;

但是当我们使用父类的对象去调用时，切片得到部分成员变量后，会调用父类的拷贝构造函数对那部分成员变量进行拷贝构造，而拷贝构造出来的父类对象p1和p2当中的虚表指针都是指向的父类对象的虚表。因为同类型的对象共享一张虚表，他们的虚表指针指向的虚表是一样的。

因此，我们使用父类对象p1和p2调用虚函数时，p1和p2通过虚表指针找到的虚表是一样的，最终调用的函数也是一样的，也就无法构成多态。

所以，我们要注意的是：

构成多态，指向谁就调用谁的虚函数，跟对象有关。
不构成多态，对象类型是什么就调用谁的虚函数，跟类型有关。

单继承和多继承中的多态

单继承中的多态

以下列单继承关系为例，我们来看看基类和派生类的虚表模型。

//基类
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;
};

其中，基类和派生类对象的虚表模型如下：

在单继承关系当中，派生类的虚表生成过程如下：

继承基类的虚表内容到派生类的虚表。

对派生类重写了的虚函数地址进行覆盖，比如func1。

虚表当中新增派生类当中新的虚函数地址，比如func3和func4。

如果我们想要查看派生类对象完整的虚表有两个方法。

方法一：使用内存窗口

我们可以大胆的猜测虚表内存连续存放着派生类对象d的虚函数地址。

方法二：打印虚表内容

我们可以使用以下代码，打印上述基类和派生类对象的虚表内容，在打印过程中可以顺便用虚函数地址调用对应的虚函数，从而打印出虚函数的函数名，这样可以进一步确定虚表当中存储的是哪一个函数的地址。

typedef void(*VFPTR)(); //虚函数指针类型重命名
//打印虚表地址及其内容
void PrintVFT(VFPTR* ptr)
{printf("虚表地址:%p\n", ptr);for (int i = 0; ptr[i] != nullptr; i++){printf("ptr[%d]:%p-->", i, ptr[i]); //打印虚表当中的虚函数地址ptr[i](); //使用虚函数地址调用虚函数}printf("\n");
}
int main()
{Base b;PrintVFT((VFPTR*)(*(int*)&b)); //打印基类对象b的虚表地址及其内容Derive d;PrintVFT((VFPTR*)(*(int*)&d)); //打印派生类对象d的虚表地址及其内容return 0;
}

运行结果如图所示：

可见我们的猜测正确。

多继承中的多态

以下列多继承关系为例，我们来看看基类和派生类的虚表模型。

//基类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;
};

其中，两个基类的虚表模型如下：

而派生类的虚表模型就不那么简单了，派生类的虚表模型如下：

在多继承关系当中，派生类的虚表生成过程如下：

分别继承各个基类的虚表内容到派生类的各个虚表当中。

对派生类重写了的虚函数地址进行覆盖(派生类中的各个虚表中存有该被重写虚函数地址的都需要进行覆盖)，比如func1。

在派生类第一个继承基类部分的虚表当中新增派生类当中新的虚函数地址，比如func3。

同样，我们也会使用两种方法去查看完整的派生类对象的虚表。

方法一：使用内存窗口

方法二：打印虚表内容

需要注意的是，我们在派生类第一个虚表地址的基础上，向后移sizeof(Base1)个字节即可得到第二个虚表的地址。

typedef void(*VFPTR)(); //虚函数指针类型重命名
//打印虚表地址及其内容
void PrintVFT(VFPTR* ptr)
{printf("虚表地址:%p\n", ptr);for (int i = 0; ptr[i] != nullptr; i++){printf("ptr[%d]:%p-->", i, ptr[i]); //打印虚表当中的虚函数地址ptr[i](); //使用虚函数地址调用虚函数}printf("\n");
}
int main()
{Base1 b1;Base2 b2;PrintVFT((VFPTR*)(*(int*)&b1)); //打印基类对象b1的虚表地址及其内容PrintVFT((VFPTR*)(*(int*)&b2)); //打印基类对象b2的虚表地址及其内容Derive d;PrintVFT((VFPTR*)(*(int*)&d)); //打印派生类对象d的第一个虚表地址及其内容PrintVFT((VFPTR*)(*(int*)((char*)&d + sizeof(Base1)))); //打印派生类对象d的第二个虚表地址及其内容return 0;
}

运行结果如下：