文章目录

• 前言
• 1、多态的概念
• 2、多态的定义以及实现
• • 2.1 虚函数的重写
  • 2.2 多态的构成条件
  • 2.3 虚函数之虚构函数的重写
  • 2.4 C++11中的关键字override和final
  • 2.5 重载、覆盖(重写)、隐藏(重定义)的对比
• 3、抽象类
• • 3.1 概念
  • 3.2 接口继承和实现继承
• 4、多态的原理
• • 4.1 虚函数表
  • 4.2 多态的原理
  • 4.3 动态绑定与静态绑定
• 5、单继承和多继承关系的虚函数表
• • 5.1 单继承中的虚函数表
  • 5.2 多继承中的虚函数表
  • 5.3. 菱形继承、菱形虚拟继承

前言

多态是C++语言和其他面向对象语言的三大特性之一

1、多态的概念

简单点来说：多态就是不同对象，进行相同操作或行为而产生的不同的结果或状态。
举个栗子：比如对于吃饭这个行为。有的人去食堂吃面条，有的人吃炒饭，也有的人吃米线。对于不同的人(不同的对象)，同样是吃饭(相同的行为)，但是吃的食物却是不同的(不同的结果)。
再举个栗子：比如我和我的高中同学都在相同的环境了学习，经过了3年的奋斗，有的同学考上了重点，有的人考上本科，也有的人考了专科。这也是多态。
再再举个栗子：某超市实行会员等级制度，积分越高，会员等级越高，折扣力度也就越大。假设有一位顾客到超市购物，因为是VIP1，所以最后结账的时候打了9.5折。又有一位顾客来该超市购物，因为是vip2，所以最后结账的时候打了9折。如果顾客不是vip用户，就没有折扣。通过对父类虚函数的重写，从而构成多态。

2、多态的定义以及实现

2.1 虚函数的重写

虚函数：即被virtual修饰的类的非静态成员函数称为虚函数

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

BuyTicket()我们就称之为虚函数。这里virtual的概念和虚拟继承中virtual的概念是完全不同的，只是使用了相同的关键字而已。前者表示虚函数，后者表示虚拟继承。

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

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

Person类时基类，Student类是派生类。Student中的虚函数BuyTicket()就是对Person中BuyTicket()的重写

2.2 多态的构成条件

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了Person。Person对象买票全价，Student对象买票半价。
那么在继承中要构成多态还有两个条件：

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

class Person {public:virtual void BuyTicket() { cout << "买票-全价" << endl; }};class Student : public Person {public:virtual void BuyTicket() { cout << "买票-半价" << endl; }};void Func1(Person& p)//通过基类引用调用虚函数{p.BuyTicket();}void Func2(Person* p)//通过基类指针调用虚函数{p->BuyTicket();}void Func3(Person p){p.BuyTicket();}int main(){Person ps;Student st;cout << "传引用:" << endl;Func1(ps);Func1(st);cout << endl;cout << "传指针:" << endl;Func2(&ps);Func2(&st);return 0;}

Student类的对象st，在传引用或者指针给父类时，是切片行为，而不是非法的。Func1()是通过基类引用调用虚函数，Func2()是通过基类指针调用虚函数。
运行代码：

结果跟我们预想的一样。
我们再来看看用基类的对象去调用虚函数：

这里为什么会造成这种原因呢？因为对派生类对象传值给基类对象时，也是进行切片处理，但是会在内存中生成一个新的基类对象，调用时就是新的基类对象调用自己的成员函数是没有多态这一说法的。而如果是派生类传指针或者引用给父类，不会在内存中生成新的对象。调用时还是原先的对象进行调用，如果对象的类型是Person类，就调用Person类的虚函数，如果是Student类，就调用Student类的虚函数。

总的来说：
如果构成多态，传的哪个类型的对象，调用的就是这个类型的虚函数----跟对象有关。
如果不构成多态，就跟调用者的类型有关----跟类型有关

2.3 虚函数之虚构函数的重写

对于这样一段代码：

class Person{public:virtual ~Person(){ cout << "~Person()" << endl; }//~Person(){ cout << "~Person()" << endl; }};class Student:public Person{public:virtual ~Student(){ cout << "~Student()" << endl; }//~Student(){ cout << "~Student()" << endl; }};int main(){Person p;Student s;return 0;}

运行代码：

我们再将父类和子类析构函数的virtual关键字去掉，再运行代码：

这里无论是否形成多态，都能正常的释放资源。

先了解这样一个概念：
如果父类的析构函数是虚函数，子类析构函数是否是虚函数，都完成了重写。为什么呢？重写的条件之一不是名字相同吗？这里的名字根本不同，为什么还是重写？
原因：如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。

有这样一种情况：

class Person {public:~Person() { cout << "~Person()" << endl; }};class Student : public Person {public:~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;}

如果没有多态，按照正常情况来说，delete p1 和 p2 都会调用父类的析构函数。对于p1来说，这是再正常不过的了，因为p1指向的空间就是Person类的。但对于p2来说，就不正常了，p2指向的空间是Student类，里面出来父类的继承下来的成员，还有自己的成员，不仅要释放继承下来的资源，也要释放本身的资源，否则会造成内存泄漏。但是这里很明显没有释放自己的资源。

因为无论析构函数的名字是什么，编译后析构函数的名称都将被统一处理成destructor
所以我们将父类和子类的析构函数都加上关键字virtual，进行重写子类的析构函数，使其形成多态，再运行代码：

这里不仅释放了父类继承下来的资源，也释放了自己本身的资源。
对于多态来说：p2会调用子类(也就是Student)的析构函数，当调用完毕后，会默认的调用父类(Person)的析构函数，很好的解决了不能释放自己本身资源的这个问题。
重点：动态申请的对象，如果给了父类指针管理，那么需要析构函数是虚函数

例如这种情况就不要：

Person* p1 = new Person;Student* p2 = new Student;delete p1;delete p2;

这里p2的类型是Student*，而p2所指向的空间也是Student，也就是说并没有给父类管理。换句话说，即使将析构函数都写成了虚函数，这里不会构成多态，因为构成多态的条件之一是需要通过父类指针或者引用进行调用虚函数。这里p2会调用自己的构造函数，然后又会调用父类的构造函数。所以并不需要析构函数是虚函数。

除此之外，如果基类的成员函数是虚函数，子类对应的成员函数加或不加virtual，都与基类的析构函数构成重写

class Person {public:virtual void BuyTicket() { cout << "买票-全价" << endl; }};class Student : public Person {public:void BuyTicket() { cout << "买票-半价" << endl; }};int main(){Person* p = new Student;p->BuyTicket();return 0;}

虚函数的重写允许父类和子类都是虚函数或者父类是虚函数，再满足返回值类型、函数名字、参数列表完全相同，就构成重写。子类会继承父类的属性(virtual和访问限定符)
虽然子类可以不写virtual，但是我们任然建议写上virtual，这样才能使得代码更加规范

2.4 C++11中的关键字override和final

final：
先思考一个问题：如何设计一个不能被继承的类？
很多人都会想到将基类的构造函数设置为私有，例如：

class A{private:A(int a = 0):_a(a){}public:int _a;};class B : public A{};int main(){B b;return 0;}

报错的原因就是通过子类B创建对象时，需要调用父类的构造函数，但父类的构造函数又是私有的，就间接限制了子类构造函数无法调用父类构造函数初始化对象。
此时有人可能会问，将父类的构造函数设置为私有，那么怎么通过父类构造对象呢？这时我们只需要在父类提供一个接口就行。

public:static A CreateOBj(int a = 0){return A(a);}A aa = A::CreateOBj(10);

这里给static的原因就是使CreateOBj()为类所有，而不是对象所有，通过类就能调用。如果不给static，就需要对象才能调用，但是构造函数是私有的，又只能通过CreateOBj才能构造对象，这时就会形成类似于先有鸡还是先有蛋的问题。

C++11觉得上面这种方式又难理解又麻烦，所以就提供了一个关键字final对这种方式进行了优化，相当于直接限制。

class A final{private:A(int a = 0):_a(a){}public:int _a;};class B : public A{};int main(){B bb;return 0;}

通过final修饰一个类，表明这个类是一个最终类，不能被继承。除了可以限制类以外，还能限制被重写。如果我们不想父类的虚函数被子类重写，也可以用final进行修饰。

class A{public:virtual void f() final{cout << "A::f()" << endl;}public:int _a;};class B : public A{virtual void f(){cout << "B::f()" << end;}};int main(){B bb;return 0;}

override：
override放在子类重写的虚函数的后面，检查是否完成重写

class A{public:virtual void f(){cout << "A::f()" << endl;}public:int _a;};class B : public A{virtual void f(int a) override{cout << "B::f()" << endl;}};int main(){B bb;return 0;}

2.5 重载、覆盖(重写)、隐藏(重定义)的对比

3、抽象类

3.1 概念

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。
纯虚函数一般只声明，不实现，即使实现了也没有价值，因为调用不到。可能此时会有人反驳，假设创造该类型的指针，通过这个指针不就调用到了吗？例如：

class f{public:void print(){cout << "hello print()" << endl;}};int main(){f* tmp=nullptr;tmp->print();return 0;}

虽然道理是这样，但是事实却事与愿违：

class f{public:virtual void print() = 0{cout << "hello print()" << endl;}};int main(){f* tmp=nullptr;tmp->print();//传nullptr，但不解引用就不算错return 0;}

这里很明显是对nullptr的解引用，所以才报错，至于原因，请再往下看。

重点：如果子类不对父类(抽象类)的纯虚函数进行重写，那么子类也会继承父类的纯虚函数，因此也不能实例化出对象

3.2 接口继承和实现继承

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

4、多态的原理

4.1 虚函数表

请看这样一个问题：

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

在32为平台下，Base类有多大？
如果有人不知道内存对齐这一概念的话，则会回答5字节
如果有人知道内存对齐这一概念的话，则会回答8字节
但对于那些知道内存对齐和虚函数表的人，它们会回答12字节

事实也确实是12，为什么呢？让我们来看看bb中到底有什么

为什么除了成员变量_f 和 _l 外，还多出个 _vfptr 呢？其实 _vfptr 就是虚函数表指针(简称虚表指针)。虚表指针指向了一张虚函数表，虚函数表里面存放的就是虚函数的地址，所以虚函数表本质就是一个函数指针数组。调用虚函数的时候需要需要通过虚函数指针找到虚函数表，再通过这张表找到虚函数的地址才能调用虚函数。
这也很好的解释了前面通过nullptr调用成员函数不报错，因为普通的成员函数放在代码段，不需要对传的指针(nullptr)进行解引用，所以不报错。而调用虚函数就需要对找到虚函数表指针，就需要对传的指针(nullptr)解引用，所以报错

4.2 多态的原理

我们先来看一下普通成员函数的调用：

class Person{public:void Print(){cout << "Print()" << endl;}private:int _a;};void Func(Person& p){p.Print();}int main(){Person per;Func(per);return 0;}

通过反汇编，我们可以看到直接通过函数的地址进行调用

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 per;Func(per);Student stu;Func(stu);return 0;}

对于多态中，重写函数的调用，是直接调用寄存器eax中的地址，eax中的地址是怎么来的呢？我们接着往下看

通过基类指针或者引用调用重写函数时，发生多态。当我们传父类时，会在父类对象中找到虚函数表指针，再通过这个指针找到需要调用的虚函数的地址。当我们传子类时，会进行切片，切片部分是父类的引用，虽然如此，但是我们在找虚函数表指针的时候还是在原来的对象中被父类引用的那部分里面找，但不同是虚函数表中的虚函数是已经被重写过的了。
所以在多态的调用过程中，虽然我们在反汇编中看到的是同样的一串指令，最终都是调用寄存器eax中的函数地址，最终调用的却是不同的函数。这就是由于虚基表中的函数指针不同，虚函数表里面存的是什么函数，我就调什么函数。
多态的原理：基类的指针或者引用，指向谁，就去谁的虚函数表中找到对应位置的虚函数进行调用

构成多态时，那为什么传对象不行，而必须传指针或者引用？

class Person {public:virtual void BuyTicket() { cout << "买票-全价" << endl; }protected:int _a;};class Student : public Person {public:virtual void BuyTicket() { cout << "买票-半价" << endl; }protected:int _b;};void Func(Person& p) {p.BuyTicket();}int main(){ Student stu;Person& r = stu;Person p = stu;return 0;}

通过对比 r(传引用) 和 p(传值)中的内容我们发现，两者的虚表指针不同。按照常理来说，对于赋值应该也将stu的虚表指针赋给p，但实际上并没有，也就不构成多态了，为什么呢？假设如果真的将stu的虚表指针赋值给p，这其实是不合常理的，因为父类对象中，怎么能有一个子类的虚表指针，这就有点乱套了呀。更严重的话，如果父类对象调用自己的析构函数，因为虚表指针是子类的，却调用了子类对象的析构函数，就可能导致程序崩溃。而父类的引用(假设为p)去接受子类的话，那么p就是子类中父类继承下来的那部分的别名，所以能构成多态，指针也是如此。
所以构成多态的条件之一：基类的指针或者引用去调用的原因也就是这样。

对于父类对象进行调用，也不会形成多态

通过反汇编我们看到，此时的函数的地址已经确定了，而不是去寄存器中取，所以不构成多态。对此我们也可以得出一个结论，满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象的中取找的。不满足多态的函数调用时编译时确认好的

对于同类型的虚表指针一不一样呢？那我们就来验证一下吧

通过验证发现，它们是一样的。如果每个对象都有一个虚函数表，那是不是就有点浪费空间了呀。所以同类型的对象，虚表指针是相同的，指向同一张虚表

普通成员函数和虚函数存储的位置是否一样呢？
答案：是一样的，都在代码段，只是虚函数要把地址存一份到虚表中，才能进行调用，方便实现多态

总结一下派生类的虚表生成：a.先将基类中的虚表内容拷贝一份到派生类虚表中 b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数 c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后

虚函数存在哪的？虚表存在哪的？
虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。那么虚表存在哪的呢？实际我们去验证一下会发现vs下是存在代码段的

4.3 动态绑定与静态绑定

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

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

5.1 单继承中的虚函数表

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(){Derive d;return 0;}

观察下图中的监视窗口中我们发现看不见func3和func4。这里是编译器的监视窗口故意隐藏了这两个函数，也可以认为是他的一个小bug，我们可以通过内存窗口观察func3和func4

除了通过内存窗口查看，我们也能通过虚函数表将表里面存放的虚函数地址打印出来

typedef void(*VF_PTR)();//对虚表里面的函数指针重命名void PrintVFTable(VF_PTR* table){for (int i = 0; table[i] != nullptr; ++i)//在vs2013中，虚表的最后默认为nullptr{printf("vft[%d]:%p\n", i, table[i]);}}int main(){Derive d;Base* p = &d;//切片处理//PrintVFTable((VF_PTR*)d);//这里不能强转，因为类型相关才能转换PrintVFTable((VF_PTR*)(*(int*)p));//因为p的指针类型是Base*,所以需要强制类型转换为int*,return 0;    //再进行解引用，就能得到虚表中第一个位置存放的数据，但此时编译器则认为它是一个整数，所以最后还需要将其转换为函数指针}

打印出的结果跟在内存中的结果一致

5.2 多继承中的虚函数表

先看这样一个多继承的代码

typedef void(*VF_PTR)();void PrintVFTable(VF_PTR* table){for (int i = 0; table[i] != nullptr; ++i){printf("vft[%d]:%p\n", i, table[i]);}}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; }private:int d1;};

在多继承中，子类的虚函数表也会有多个。子类自己的虚函数将会放在先继承的虚表中

查看第一张虚表

int main(){Derive d;PrintVFTable((VF_PTR*)(*(void**)&d));return 0;}

查看第二张虚表

int main(){Derive d;PrintVFTable((VF_PTR*)(*(void**)((char*)&d + sizeof(Base1))));return 0; //将d的地址强转为char*，再加上Base1的大小就是Base2的地址}//因为先继承的放在低地址处，后继承的放在高地址处。//当我们需要找到后继承的虚表时，需要后继承的位置(相对先继承的位置)//我们也可以通过切片处理，也能找到Base2的地址Base2* p = &d;PrintVFTable((VF_PTR*)(*(void**)p);

5.3. 菱形继承、菱形虚拟继承

实际中我们不建议设计出菱形继承及菱形虚拟继承，一方面太复杂容易出问题，另一方面这样的模型，访问基类成员有一定得性能损耗。
所以就不介绍了，有兴趣的请看下面这两篇文章
1、C++虚函数表解析
C++对象的内存布局