Cpp多态机制的深入理解(20)

---

前言

  多态也是三大面向对象语言的特性之一，同时我也觉得他也蛮有意思的
  与封装“一个方法，多个接口”差别的是，多态可以实现 “一个接口，多种方法”
  调用同名函数时，可以根据差别的对象（父类对象或子类对象）调用属于自己的函数，实现差别的方法，因此 多态 的实现依赖于 继承

---

一、多态的概念

  在使用多态的代码中，差别对象完成同一件事会产生差别的效果
  比如在购买高铁票时，普通人原价，门生半价，而军人可以优先购票，对于 购票 这一雷同的动作，需要 根据差别的对象提供差别的方法
二、多态的定义与实现

两个必要条件

• virtual 修饰后形成的虚函数，与其他类中的虚函数形成 重写（三同：返回值、函数名、参数均雷同）
  
• 必须通过【父类指针】或【父类引用】进行虚函数调用
  

虚函数

  被virtual修饰的类成员函数称为虚函数
   全局虚函数没有意义，由于虚函数是为多态而用的
  

虚函数的重写

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

1. // 基类
2. class Person
3. {
4. public:
5.     // 虚函数
6.     virtual void BuyTicket() { cout << "买票-全价" << endl; }
7. };
9. // 派生类
10. class Student : public Person
11. {
12. public:
13.     // 虚函数重写
14.     virtual void BuyTicket() { cout << "买票-半价" << endl; }
15. };
17. // 三种函数实现
18. // 引用
19. void Func(Person& p)
20. {
21.         p.BuyTicket();
22. }
24. // 指针
25. //void Func(Person* p)
26. //{
27. //        p->BuyTicket();
28. //}
30. // 非引用指针，调用父类
31. //void Func(Person p)
32. //{
33. //        p.BuyTicket();
34. //}

复制代码

测试效果：

重写的三个例外

• 协变(基类与派生类虚函数返回值范例差别)
  

  派生类重写基类虚函数时，与基类虚函数返回值范例差别。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变
   这个相识一下就行，现实我感觉挺没啥用处的
假如你也有这种感觉，鼓励你致电老本，去好好批斗他！

1. class A {};
2. class B : public A {};
4. class Person
5. {
6. public:
7.         // 协变 返回值可以是父子类对象指针或引用
8.         //virtual A* BuyTicket() // 返回值是父类指针
9.         virtual Person* BuyTicket()
10.         {
11.                 cout << "Person-> 买票-全价" << endl;
12.                 return nullptr;
13.         }
14. };
16. class Student : public Person
17. {
18. public:
19.         //virtual B* BuyTicket()// 返回值是子类指针
20.         virtual Student* BuyTicket()
21.         {
22.                 cout << "Student-> 买票-半价" << endl;
23.                 return nullptr;
24.         }
25. };

复制代码

• 析构函数的重写(基类与派生类析构函数的名字差别)
  

  假如基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，固然基类与派生类析构函数名字差别。固然函数名不雷同，看起来违背了重写的规则，实在否则，这里可以理解为编译器对析构函数的名称做了特别处理惩罚，编译后析构函数的名称统一处理惩罚成destructor

1. class Person
2. {
3. public:
4.         // 析构函数名不同，构成重写，编译器将析构函数名字统一处理成destructor
5.         virtual ~Person()
6.         {
7.                 cout << "~Person()" << endl;
8.         }
9. };
11. class Student : public Person
12. {
13. public:
14.     virtual ~Student()
15.         {
16.                 cout << "delete[]" << _ptr << endl;
17.                
18.                 delete[] _ptr;
19.                 cout << "~Student()" << endl;
20.         }
21. private:
22.         int* _ptr = new int[10];
23. };
25. void Func(Person& p)
26. {
27.         p.BuyTicket();
28. }
30. int main()
31. {
32.         // 正常情况调用析构没有问题
33.         //Person p;
34.         //Student s;
35.         //Func(p);
36.         //Func(s);
38.         // 派生类有动态开辟的内存，需要调用多态
39.         // 指向谁调用谁
40.         Person* p1 = new Person;
41.         Person* p2 = new Student;
43.         delete p1;
44.         delete p2;
46.         return 0;
47. }

复制代码

• 派生类重写虚函数virtual关键字可以省略
  

1. class Person
2. {
3. public:
4.         virtual ~Person()
5.         {
6.                 cout << "~Person()" << endl;
7.         }
8. };
10. class Student : public Person
11. {
12. public:
13.     // 派生类virtual关键字省略
14.         ~Student()
15.         {
16.                 cout << "~Student()" << endl;
17.         }
18. };

复制代码

override 和 final

  C++对函数重写的要求比较严酷，但是有些情况下由于疏忽，大概会导致函数名字母次序写反而无法构成重载

• final：修饰虚函数，表示该虚函数不能再被重写
  
• override: 检查派生类虚函数是否重写了基类某个虚函数，假如没有重写编译报错
  

1. // final 修饰虚函数，不能重写
2. class Car
3. {
4. public:
5.         // 加了final关键字，虚函数不能被重写
6.         virtual void Drive() final {}
7. };
9. class Benz :public Car
10. {
11. public:
12.         virtual void Drive() { cout << "Benz-舒适" << endl; }
13. };
15. int main()
16. {
17.         Benz b;
18.         return 0;
19. }

复制代码

重载、重写(覆盖)、重定义(隐藏)

三、抽象类

概念

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

1. class Car
2. {
3. public:
4.         // 纯虚函数 强制派生类重写虚函数
5.         virtual void Drive() = 0;
6. };
8. int main()
9. {
10.         Car c;
11.         return 0;
12. }

复制代码

1. class Car
2. {
3. public:
4.         // 纯虚函数 强制派生类重写虚函数
5.         virtual void Drive() = 0;
6. };
8. class Benz :public Car
9. {
10. public:
11.         virtual void Drive()
12.         {
13.                 cout << "Benz-舒适" << endl;
14.         }
15. };
17. class BMW :public Car
18. {
19. public:
20.         virtual void Drive()
21.         {
22.                 cout << "BMW-操控" << endl;
23.         }
24. };
26. int main()
27. {
28.         // Car c;
29.         Benz b1;
30.         BMW b2;
32.         // 基类可以定义指针 指向谁调用谁
33.         Car* ptr1 = &b1;
34.         Car* ptr2 = &b2;
36.         ptr1->Drive();
37.         ptr2->Drive();
38.        
39.         return 0;
40. }

复制代码

接口继承和实现继承

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

  在讲解原理之前，不如我们先来看这么一段神奇代码

1. #include <iostream>
2. using namespace std;
4. class Test
5. {
6.         virtual void func() {};
7. };
9. int main()
10. {
11.         Test t;        //创建一个对象
12.         cout << "Test sizeof(): " << sizeof(t) << endl;
13.        
14.         return 0;
15. }

复制代码

  大概你会觉得没有对象，会觉得是0，但是你忽然想起了之前讲过的空类也占内存空间，你大概会想是不是1
  但是实在都错了，真相是4/8（取决于你的体系是32位照旧64位），大概我这么一说，你也猜到了实在有一个隐藏变量，且范例是指针范例
   实在，就是靠着这个虚表指针和虚表实现了多态
  虚表和虚表指针

  在 vs 的监视窗口中，可以看到涉及虚函数类的对象中都有属性 __vfptr（虚表指针），可以通过虚表指针所指向的地址，找到对应的虚表
  虚函数表中存储的是虚函数指针，可以在调用函数时根据差别的地址调用差别的方法
   大概有点混，有三个“虚”，大家别被整虚了！
虚表指针指向虚表，虚表里面存放着虚函数指针，以是虚表的本质实在是个函数指针数组
    接下来我会给出一段代码，在该代码中父类 Person 有两个虚函数（func3 不是虚函数），子类 Student 重写了 func1 这个虚函数，同时新增了一个 func4 虚函数

1. #include <iostream>
3. using namespace std;
5. class Person
6. {
7. public:
8.         virtual void func1() { cout << "Person::fun1()" << endl; };
9.         virtual void func2() { cout << "Person::fun2()" << endl; };
10.         void func3() { cout << "Person::fun3()" << endl; };        //fun3 不是虚函数
11. };
13. class Student : public Person
14. {
15. public:
16.         virtual void func1() { cout << "Student::fun1()" << endl; };
18.         virtual void func4() { cout << "Student::fun4()" << endl; };
19. };
21. int main()
22. {
23.         Person p;
24.         Student s;
25.        
26.     return 0;
27. }

复制代码

1. //打印虚表
2. typedef void(*VF_T)();
4. void PrintVFTable(VF_T table[])        //也可以将参数类型设为 VF_T*
5. {
6.         //vs中在虚表的结尾处添加了 nullptr
7.         //如果运行失败，可以尝试清理解决方案重新编译
8.         int i = 0;
9.         while (table[i])
10.         {
11.                 printf("[%d]:%p->", i, table[i]);
12.                 VF_T f = table[i];
13.                 f();        //调用函数，相当于 func()
14.                 i++;
15.         }
16.         cout << endl;
17. }
20. int main()
21. {
22.         //提取出虚表指针，传递给打印函数
23.         Person p;
24.         Student s;
26.         //第一种方式：强转为虚函数地址（4字节）
27.         PrintVFTable((VF_T*)(*(int*)&p));
28.         PrintVFTable((VF_T*)(*(int*)&s));
30.         return 0;
31. }

复制代码

子类重写后的虚函数地址与父类差别

   由于平台差别指针巨细差别，因此上述传递参数的方式(VF_T * )( * (int * )&p 具有肯定的范围性
假设在 64 位平台下，需要更改为 (VF_T * )( * (long long * )&p

1. //64 位平台下指针大小为 8字节
2. PrintVFTable((VF_T*)(*(long long*)&p));
3. PrintVFTable((VF_T*)(*(long long*)&s));

复制代码

  除此之外还可以间接将虚表指针转为 VF_T* 范例进行参数传递

1. //同时适用于 32位 和 64位 平台
2. PrintVFTable(*(VF_T**)&p);
3. PrintVFTable(*(VF_T**)&s);

复制代码

传递参数时的范例转换路径

  不能直接写成 PrintVFTable((VF_T*)&p);，由于此时取的是整个虚表区域的首地址地址，无法定位我们所需要虚表的首地址，打印时会堕落
  综上所述，虚表是真实存在的，只要当前类中涉及了虚函数，那么编译器就会为其构建相应的虚表体系
   虚表是在 编译 阶段生成的
虚表指针是在构造函数的 初始化列表 中初始化的
虚表一样平常存储在 常量区（代码段），有的平台中大概存储在 静态区（数据段）

1. int main()
2. {
3.         //验证虚表的存储位置
4.         Person p;
5.         Student s;
7.         int a = 10;        //栈
8.         int* b = new int;        //堆
9.         static int c = 0;        //静态区（数据段）
10.         const char* d = "xxx";        //常量区（代码段）
12.         printf("a-栈地址：%p\n", &a);
13.         printf("b-堆地址：%p\n", b);
14.         printf("c-静态区地址：%p\n", &c);
15.         printf("d-常量区地址：%p\n", d);
17.         printf("p 对象虚表地址：%p\n", *(VF_T**)&p);
18.         printf("s 对象虚表地址：%p\n", *(VF_T**)&s);
20.         return 0;
21. }

复制代码

   显然，虚表地址与常量区的地址非常接近，因此可以推测 虚表 位于常量区中，由于它需要被同一类中的差别对象共享，同时不能被修改（如同代码一样）
  虚函数调用过程

综上，我们可以大概想象出多态的原理了：

• 起首确保存在虚函数且构成重写
  
• 其次使用【父类指针】或【父类引用】指向对象，其中包罗切片行为
  
• 切片后，将子类中不属于父类的切掉，只保存父类指针可调用到的部门函数
  
• 现实调用时，父类指针的调用逻辑是一致的：比如虚表第一个位置调用第一个函数，虚表第二个位置调用第二个函数，但是由于此时的虚表是切片得到的，以是 同一位置 可以调用到差别的函数，这就是多态
  

   也就是说，父类和子类的虚表实在是不一样的，在构成重写的条件下！
这就是多态！

1. int main()
2. {
3.         Person* p1 = new Person();
4.         Person* p2 = new Student();
6.         p1->func1();
7.         p2->func1();
9.         delete p1;
10.         delete p2;
11.         return 0;
12. }

复制代码

通过汇编代码来看的话：

动态绑定与静态绑定

  实在我们想一想，函数重载某种程度上也是一种多态，也是一个函数面临差别对象的时候有差别的效果，但是差别的是，重载在编译的时候就确定了待调用函数的地址，而动态绑定的代码，待调用地址存放在 eax 中，不确定

五、那…那单继承甚至多继承呢？

  坦率说，这很麻烦，我也不敢说我很懂，于是我在这里贴两篇文章，大家自行参阅吧！
《C++虚函数表解析》
《C++对象的内存布局》

---

总结

  我们终于学完三大面向对象特性了，坦率说，多态照旧蛮困难的，但是，我们难度的最高峰再过几篇就要来了，怕不怕！

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