【C++】深入浅出之多态

多态的概念

   多态就是函数调用的时间的多种形态，差异的对象去做同一件事变会有差异的结果，这就叫做多态
  

• 比方，在实际生存当中，平凡人买票是全价，门生买票是半价，而武士允许优先买票。差异身份的人去买票，所产生的活动是差异的，这就是所谓的多态。
  

多态的界说和实现

多态的构造条件

多态是指差异继承关系的类对象，去调用同一函数，产生了差异的活动。在继承中要想构成多态须要满意两个条件：

• 必须通过基类的指针大概引用调用虚函数。
  
• 被调用的函数必须是虚函数，且派生类必须对基类的虚函数举行重写。
  

虚函数

• 被virtual修饰的类成员函数被称为虚函数。
  

1. class Person
2. {
3. public:
4.         //被virtual修饰的类成员函数
5.         virtual void BuyTicket()
6.         {
7.                 cout << "买票-全价" << endl;
8.         }
9. };

复制代码

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

虚函数的重写

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

比方，我们以下Student和Soldier两个子类重写了父类Person的虚函数。

1. //父类
2. class Person
3. {
4. public:
5.         //父类的虚函数
6.         virtual void BuyTicket()
7.         {
8.                 cout << "买票-全价" << endl;
9.         }
10. };
11. //子类
12. class Student : public Person
13. {
14. public:
15.         //子类的虚函数重写了父类的虚函数
16.         virtual void BuyTicket()
17.         {
18.                 cout << "买票-半价" << endl;
19.         }
20. };
21. //子类
22. class Soldier : public Person
23. {
24. public:
25.         //子类的虚函数重写了父类的虚函数
26.         virtual void BuyTicket()
27.         {
28.                 cout << "优先-买票" << endl;
29.         }
30. };

复制代码

• 现在我们就可以通过父类Person的指针大概引用调用虚函数BuyTicket，此时差异范例的对象，调用的就是差异的函数，产生的也是差异的结果，进而实现了函数调用的多种形态。
  
• 这里为啥要用基类指针才可以？外貌上是基类指针即可以指向基类对象也可以指向派生类对象，深层是反面多态的原理：基类指针可以找到父类和子类对象的虚表指针（反面多态原剖析讲）
  

1. void Func(Person& p)
2. {
3.         //通过父类的引用调用虚函数
4.         p.BuyTicket();
5. }
6. void Func(Person* p)
7. {
8.         //通过父类的指针调用虚函数
9.         p->BuyTicket();
10. }
11. int main()
12. {
13.         Person p;   //普通人
14.         Student st; //学生
15.         Soldier sd; //军人
17.         Func(p);  //买票-全价
18.         Func(st); //买票-半价
19.         Func(sd); //优先买票
21.         Func(&p);  //买票-全价
22.         Func(&st); //买票-半价
23.         Func(&sd); //优先买票
24.         return 0;
25. }

复制代码

注意： 在重写基类虚函数时，派生类的虚函数不加virtual关键字也可以构成重写，重要缘故原由是由于继承后基类的虚函数被继承下来了，在派生类中仍旧保持虚函数属性(注意这个词哦，反面有道题这个坑)。但是这种写法不是很规范，因此发起在派生类的虚函数前也加上virtual关键字。
虚函数重写的两个破例

协变

   协变（基类与派生类虚函数的返回值范例差异）
  

• 派生类重写基类虚函数时，与基类虚函数返回值范例差异。即基类虚函数返回基类对象的指针大概引用，派生类虚函数返回派生类对象的指针大概引用，称为协变。
  
• 比方，下列代码中基类Person当中的虚函数fun的返回值范例是基类A对象的指针，派生类Student当中的虚函数fun的返回值范例是派生类B对象的指针，此时也以为派生类Student的虚函数重写了基类Person的虚函数。
  

1. //基类
2. class A
3. {};
4. //子类
5. class B : public A
6. {};
7. //基类
8. class Person
9. {
10. public:
11.         //返回基类A的指针
12.         virtual A* fun()
13.         {
14.                 cout << "A* Person::f()" << endl;
15.                 return new A;
16.         }
17. };
18. //子类
19. class Student : public Person
20. {
21. public:
22.         //返回子类B的指针
23.         virtual B* fun()
24.         {
25.                 cout << "B* Student::f()" << endl;
26.                 return new B;
27.         }
28. };

复制代码

• 此时，我们通过父类Person的指针调用虚函数fun，父类指针若指向的是父类对象，则调用父类的虚函数，父类指针若指向的是子类对象，则调用子类的虚函数。
  

1. int main()
2. {
3.         Person p;
4.         Student st;
5.         //父类指针指向父类对象
6.         Person* ptr1 = &p;
7.         //父类指针指向子类对象
8.         Person* ptr2 = &st;
9.         //父类指针ptr1指向的p是父类对象，调用父类的虚函数
10.         ptr1->fun(); //A* Person::f()
11.         //父类指针ptr2指向的st是子类对象，调用子类的虚函数
12.         ptr2->fun(); //B* Student::f()
13.         return 0;
14. }

复制代码

析构函数作为虚函数重写

• 那父类和子类的析构函数构成重写的意义安在呢？试想以了局景：分别new一个父类对象和子类对象，并均用父类指针指向它们，然后分别用delete调用析构函数并开释对象空间。
  

1. //父类
2. class Person
3. {
4. public:
5.         virtual ~Person()
6.         {
7.                 cout << "~Person()" << endl;
8.         }
9. };
10. //子类
11. class Student : public Person
12. {
13. public:
14.         virtual ~Student()
15.         {
16.                 cout << "~Student()" << endl;
17.         }
18. pivate:
19.         int * p = new int[10];
20. };

复制代码

1. int main()
2. {
3.         //分别new一个父类对象和子类对象，并均用父类指针指向它们
4.         Person* p1 = new Person;
5.         Person* p2 = new Student;
7.         //使用delete调用析构函数并释放对象空间
8.         delete p1;
9.         delete p2;
10.         return 0;
11. }

复制代码

• 在这种场景下，假如父类和子类的析构函数没有构成重写就会导致内存走漏，由于此时delete p1和delete p2都是调用的父类的析构函数，派生类student的p指针并没有通过调用派生类的析构函数来开释空间/mark>，而我们所盼望的是p1调用父类的析构函数，p2调用子类的析构函数，即我们盼望的是一种多态活动。
  
• 此时只有父类和子类的析构函数构成了重写，才华使得delete按照我们的预期举行析构函数的调用，才华实现多态。因此，为了克制出现这种情况，比力发起将父类的析构函数界说为虚函数。
  
• 现在多态的第一个条件基类的指针或引用已经有了，还差一个重写。重写要求同名，同返回值，同参数列表，我们的析构函数只有同名不满意，以是编译器编译的时间会欺压把全部析构函数的名字更换为destructort，以是基类的析构函数加了 vialtual修饰，派⽣类的析构函数就构成重写。
  
• 知识扩展：
  在继承当中，子类和的析构函数和父类的析构函数构成隐蔽的缘故原由就在这里，这里外貌上看子类的析构函数和父类的析构函数的函数名差异，但是为了构成重写，编译后析构函数的名字会被同一处理惩罚成destructor();。
  

C++11的override和final

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

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

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

1. //父类
2. class Person
3. {
4. public:
5.         //被final修饰，该虚函数不能再被重写
6.         virtual void BuyTicket() final
7.         {
8.                 cout << "买票-全价" << endl;
9.         }
10. };
11. //子类
12. class Student : public Person
13. {
14. public:
15.         //重写，编译报错
16.         virtual void BuyTicket()
17.         {
18.                 cout << "买票-半价" << endl;
19.         }
20. };
21. //子类
22. class Soldier : public Person
23. {
24. public:
25.         //重写，编译报错
26.         virtual void BuyTicket()
27.         {
28.                 cout << "优先-买票" << endl;
29.         }
30. };

复制代码

  override：查抄派生类虚函数是否重写了基类的某个虚函数，假如没有重写则编译报错。
  

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

1. //父类
2. class Person
3. {
4. public:
5.         virtual void BuyTicket()
6.         {
7.                 cout << "买票-全价" << endl;
8.         }
9. };
10. //子类
11. class Student : public Person
12. {
13. public:
14.         //子类完成了父类虚函数的重写，编译通过
15.         virtual void BuyTicket() override
16.         {
17.                 cout << "买票-半价" << endl;
18.         }
19. };
20. //子类
21. class Soldier : public Person
22. {
23. public:
24.         //子类没有完成了父类虚函数的重写，因为重写要求参数列表相同，编译报错
25.         virtual void BuyTicket(int i) override
26.         {
27.                 cout << "优先-买票" << endl;
28.         }
29. };

复制代码

重载、重写(覆盖)、隐蔽(重界说)的对比

干系口试题⭐

• 1.这里派生类的指针去调用public继承下来的基类函数test, 那么test内里又去调用func, this(A*，j基类)指针调用func, 那么这里满意多态吗？
  
• 多态两个条件
  (1)：要实现多态结果，第⼀必须是基类的指针或引⽤，由于只有基类的指针或引⽤才华既指向基类对象也可以指向派⽣类对象(切片)；这里已经满意了(this指针(A*)基类指针调用虚函数)
  (2)第⼆派⽣类必须对基类的虚函数重写/覆盖，重写大概覆盖了，派⽣类才华有差异的函数，多态的差异形态结果才华到达。这里也到达了把，func函数在基类和派生类的i函数名，返回值，形参列表完全划一，就是谁人缺省参数值不一样。但是参数列表只要是缺省参数值范例和名字类似就行了，并没有规定缺省值类似,
  
• 注意：在重写基类虚函数时，派⽣类的虚函数在不加virtual关键字时，固然也可以构成重写(由于继承后基类的虚函数被继承下来了在派⽣类仍旧保持虚函数属性)，但是该种写法不是很规范，不发起如许 使⽤.
  
• 有的人就说了，那肯定是选D了，那么这里的派生类指针去调用test传已往指向派生类对象，就去调用派生类的重写虚函数，那么应该是B->0呀，派生类内里的缺省值不是0吗，以是我们前面标注的重写相称于继承属性这个是什么属性，实际上就是把基类的虚函数的缺省值属性拿下来用，基类的虚函数缺省值是1。以是选B
  
• 注意：只有多态才是如许的结果，以是这道题也告诫我们，重写虚函数构成多态的时间不要让重写虚函数的基类和派生类的缺省值不一样
  

抽象类

概念

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

1. #include <iostream>
2. using namespace std;
3. //抽象类（接口类）
4. class Car
5. {
6. public:
7.         //纯虚函数
8.         virtual void Drive() = 0;
9. };
10. int main()
11. {
12.         Car c; //抽象类不能实例化出对象，error
13.         return 0;
14. }

复制代码

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

1. #include <iostream>
2. using namespace std;
3. //抽象类（接口类）
4. class Car
5. {
6. public:
7.         //纯虚函数
8.         virtual void Drive() = 0;
9. };
10. //派生类
11. class Benz : public Car
12. {
13. public:
14.         //重写纯虚函数
15.         virtual void Drive()
16.         {
17.                 cout << "Benz-舒适" << endl;
18.         }
19. };
20. //派生类
21. class BMV : public Car
22. {
23. public:
24.         //重写纯虚函数
25.         virtual void Drive()
26.         {
27.                 cout << "BMV-操控" << endl;
28.         }
29. };
30. int main()
31. {
32.         //派生类重写了纯虚函数，可以实例化出对象
33.         Benz b1;
34.         BMV b2;
35.         //不同对象用基类指针调用Drive函数，完成不同的行为
36.         Car* p1 = &b1;
37.         Car* p2 = &b2;
38.         p1->Drive();  //Benz-舒适
39.         p2->Drive();  //BMV-操控
40.         return 0;
41. }

复制代码

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

• 抽象类可以更好的去表现实际天下中，没有实例对象对应的抽象范例，比如：植物、人、动物等。
  
• 抽象类很好的表现了虚函数的继承是一种接口继承，欺压子类去重写纯虚函数，由于子类假如不重写从父类继承下来的纯虚函数，那么子类也是抽象类也不能实例化出对象。
  

接口继承和实现继承

• 实现继承：平凡函数继承下来就是一个实现继承，派生类继承了基类函数的实现，可以使用该函数
  
• 接口继承：虚函数的继承就是一种接口继承，派生类继承的是虚函数的接口，目标是为了完成重写，实现多态
  

多态的原理

虚函数表

   下面是一道常考的笔试题：Base类实例化出对象的巨细是多少？

1. class Base
2. {
3. public:
4.         virtual void Func1()
5.         {
6.                 cout << "Func1()" << endl;
7.         }
8. private:
9.         int _b = 1;
10. };

复制代码

• 通过观察测试，我们发现Base类实例化的对象b的巨细是8个字节。(内存对齐，参考这篇内存对齐详解
  
• b对象当中除了_b成员外，实际上尚有一个_vfptr放在对象的前面（有些平台大概会放到对象的末了面，这个跟平台有关）。
  
  
  
  
• 对象中的这个指针叫做虚函数表指针，简称虚表指针，虚表指针指向一个虚函数表，简称虚表，每一个含有虚函数的类中都至少有一个虚表指针。
  

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

• 下面Base类当中有三个成员函数，此中Func1和Func2是虚函数，Func3是平凡成员函数，子类Derive当中仅对父类的Func1函数举行了重写。
  

1. #include <iostream>
2. using namespace std;
3. //父类
4. class Base
5. {
6. public:
7.         //虚函数
8.         virtual void Func1()
9.         {
10.                 cout << "Base::Func1()" << endl;
11.         }
12.         //虚函数
13.         virtual void Func2()
14.         {
15.                 cout << "Base::Func2()" << endl;
16.         }
17.         //普通成员函数
18.         void Func3()
19.         {
20.                 cout << "Base::Func3()" << endl;
21.         }
22. private:
23.         int _b = 1;
24. };
25. //子类
26. class Derive : public Base
27. {
28. public:
29.         //重写虚函数Func1
30.         virtual void Func1()
31.         {
32.                 cout << "Derive::Func1()" << endl;
33.         }
34. private:
35.         int _d = 2;
36. };
37. int main()
38. {
39.         Base b;
40.         Derive d;
41.         return 0;
42. }

复制代码

• 通过调试可以看到，父类和子类对象都有一个虚表指针，分别指向属于自己的虚表。
  
  
  
  
• 实际上虚表当中存储的就是虚函数的地点，由于父类当中的Func1和Func2都是虚函数，以是父类对象b的虚表当中存储的就是虚函数Func1和Func2的地点。(注意虚函数表只会存储虚函数的地点，平凡函数的地点并不会存储)
  
• 而子类继承了基类的3个函数，此中有两个虚函数Func1和Func2,但是子类对父类的虚函数Func1举行了重写，可以看到重写后的Func1在子类中的地点和在父类中Func1的地点是不一样的，而在子类中没有重写的Func2地点跟在父类中的Func2的地点一样，这就是为什么虚函数的重写也叫做覆盖，覆盖就是指虚表中虚函数地点的覆盖，重写是语法的叫法，覆盖是原理层的叫法。
  

   总结一下，派生类的虚表天生步调如下：
  

• 把基类中的虚函数表的虚函数copy一份放在子类的虚函数表中
  
• 假如派生类重写了基类中的某个虚函数，则用派生类自己的虚函数地点覆盖虚表中基类的虚函数地点。
  

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

• 1.虚体实际上是在构造函数初始化列表阶段初始化的，注意虚表中存储的不是虚函数，而是虚函数的地点
  
• 虚函数和平凡函数一样，都是存储在代码段的。只是他的地点又存在在了虚表中，别的对象中存储的不是虚表，而是指向虚表的指针。
  
• 虚表是什么阶段初始化的？虚函数存在那边？虚表存在那边？
  

1. int j = 0;
2. int main()
3. {
4.         Base b;
5.         Base* p = &b;
6.         printf("vfptr:%p\n", *((int*)p)); //000FDCAC
7.         int i = 0;
8.         printf("栈上地址:%p\n", &i);       //005CFE24
9.         printf("数据段地址:%p\n", &j);     //0010038C
11.         int* k = new int;
12.         printf("堆上地址:%p\n", k);       //00A6CA00
13.         char* cp = "hello world";
14.         printf("代码段地址:%p\n", cp);    //000FDCB4
15.         return 0;
16. }

复制代码

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

多态的原理

   那到底多态的原理是什么？
  比方，下面代码中，为什么当父类Person指针指向的是父类对象Mike时，调用的就是父类的BuyTicket，当父类Person指针指向的是子类对象Johnson时，调用的就是子类的BuyTicket?

1. #include <iostream>
2. using namespace std;
3. //父类
4. class Person
5. {
6. public:
7.         virtual void BuyTicket()
8.         {
9.                 cout << "买票-全价" << endl;
10.         }
11.         int _p = 1;
12. };
13. //子类
14. class Student : public Person
15. {
16. public:
17.         virtual void BuyTicket()
18.         {
19.                 cout << "买票-半价" << endl;
20.         }
21.         int _s = 2;
22. };
23. int main()
24. {
25.         Person Mike;
26.         Student Johnson;
27.         Johnson._p = 3; //以便观察是否完成切片
28.         Person* p1 = &Mike;
29.         Person* p2 = &Johnson;
30.         p1->BuyTicket(); //买票-全价
31.         p2->BuyTicket(); //买票-半价
32.         return 0;
33. }

复制代码

• 通过调试可以发现，Mike对象中包罗一个成员变量_p和一个虚表指针，对象Johnson中包罗两个成员变量_p和_s以及一个虚表指针，这两个对象当中的虚表指针分别指向自己的虚表。
  
  
  
  
• 围绕此图分析便可得到多态的原理：
  
• 父类指针指向Mike对象，p1->BuyTicket在Mike的虚表中找到的虚函数就是Person::BuyTicket。
  
• 父类指针p2指向Johnson对象，p2>BuyTicket在Johnson的虚表中找到的虚函数就是Student::BuyTicket。
  

如许就实现出了差异对象去完成同一活动时，显现出差异的形态。
   现在想一下多态的两个条件。一个是完成虚函数的重写，这个是为了我们使用两个类虚表中的虚函数的时间，对子类虚表中的虚函数地点举行覆盖，到达同一个函数差异结果，以是我们要重写。那么为啥必须是基类的指针呢？能不能是基类对象呢？

1. Person* p1 = &Mike;
2. Person* p2 = &Johnson;

复制代码

• 使用父类的指针或引用的时间，我们在继承那说过，实际上基类的指针和引用会把在子类对象中基类那部门切片，就是指向或引用子类中基类的那部门
  
  
  
  
• 这里我们就要增补一个很告急的概念，差异类中的虚表是不一样的，以是我们虽说是继承下来基类的虚表，指向基类的那部门有虚表，但是我们的虚表和基类是不一样的。
  
• 因此，我们后序用p1和p2调用虚函数时，p1和p2通过虚表指针找到的虚表是不一样的，终极调用的函数也是不一样的。
  

1. Person p1 = Mike;
2. Person p2 = Johnson;

复制代码

• 那么基类对象为啥就不可呢？这里假如我们想给p1和p2两个父类对象赋值，就要去调用父类拷贝构造，拷贝构造出来两个父类对象，刚刚说了，同一个类的虚函数表是同一个。那么他们的虚表指针是指向同一个虚函数表
  
  
  
  
• 因此，我们后序用p1和p2调用虚函数时，p1和p2通过虚表指针找到的虚表是一样的，终极调用的函数也是一样的，也就无法构成多态。
  
• 前面的指针和引用，指针指向父类对象，引用通过切片引用的是派生类中的基类部门，实际上范例还是一个派生类，以是他们范例差异，虚表指针指向两个差异的虚表。
  

动态绑定和静态绑定

• 静态绑定，就是只在编译的时间就举行了多态厘革，也成为静态多态，比如：函数重载。
  
• 动态绑定，就出指在运行的时间举行了多态厘革，我们本日说的就是动态的多态。
  

end

好了，多态这部门就说完了，谢谢你的阅读，渴望多你有资助

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。