C++多态详解

多态的使用

概念

   多态分为静态多态（编译时多态）和动态多态（运行时多态）。
静态多态是函数重载和函数模版，传差别类型的参数可以调差别的函数，通过参数的差别到达了多种形态。静态是因为实参传给形参的参数匹配是在编译时完成的。
动态多态是传差别的对象完成差别的活动（函数），到达多种形态，比如买票这个活动，普通人买票时全价，学生买票是半价，武士买票是优先买票。

  多态的构成条件和使用

• 多态的构成条件:
  多态是一个继续关系下的类对象，调用同一个函数，产生差别的活动
  
• 虚函数
  

1. class Person
2. {
3. public:
4.         // 虚函数
5.         virtual void Func()
6.         {
7.                 cout << "买票" << endl;
8.         }
9. };

复制代码

• 虚函数的重写/覆盖
  重写/覆盖的条件：子类必须有一个和父类完全雷同的虚函数（返回值类型，函数名，参数列表的类型完全雷同）
  重写是重写了实现
  
• 实现多态的两个紧张条件:
  

• 必须是父类的指针或引用调用虚函数
  
• 被调用的函数必须是虚函数，且子类必须对父类虚函数完成重写/覆盖
  

满意多态指向谁调用谁，不满意多态看函数参数的类型是什么就调用什么

1. class Person
2. {
3. public:
4.         // 条件3
5.         virtual void BuyTicket() { cout << "买票-全价" << endl; }
6. };
8. class Student : public Person
9. {
10. public:
11.     // 条件3
12.         virtual void BuyTicket() { cout << "买票-打折" << endl; }
13. };
15. // 不满足多态的情况下指向谁调用谁,ptr指向Person类都调用Person类
16. // 满足多态就和指向对象的类型有关是哪个对象类型就调用哪个类
17. void Func(Person* ptr)// 条件1
18. {
19.         // 这⾥可以看到虽然都是Person指针Ptr在调⽤BuyTicket
20.         // 但是跟ptr没关系，而是由ptr指向的对象决定的。
21.         ptr->BuyTicket();// 条件2
22. }
24. int main()
25. {
26.         Person ps;
27.         Student st;
29.         Func(&ps);
30.         Func(&st);
32.         return 0;
33. }

复制代码

• 注意：在重写基类虚函数时，派⽣类的虚函数在不加virtual关键字时，虽然也可以构成重写(因为继续后基类的虚函数被继续下来了在派生类仍旧保持虚函数属性)，但是该种写法不是很规范，不建议这样使用，许多题有这样的坑。
  

子类的子类也可以不加virtual,只要父类加了virtual，就能继续下来
一道选择题

B

重写的本质是重写虚函数的实现部分
绝不重新定义继续而来的缺省值，保留原来的缺省值

1. class A
2. {
3. public:
4.         virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }
5.         virtual void test() { func(); }
6. };
8. class B : public A
9. {
10. public:
11.         void func(int val = 0) { std::cout << "B->" << val << std::endl; }
12. };
14. int main(int argc, char* argv[])
15. {
16.         B* p = new B;
18.         p->test();
19.         // B->1
20.         p->func();
21.         // B->0
22.         //  没有构成多态，是子类的指针
23.         //  在自己的域里找，找不到到继承的域里找
24.        
25.         return 0;
26. }

复制代码

协变（了解）

• 子类重写父类虚函数时，与父类虚函数返回值类型差别。即父类虚函数返回父类对象的指针大概引
  用，子类虚函数返回子类对象的指针大概引用时，称为协变。
  

1. class A {};
2. class B : public A {};
3. // 返回的类必须也必须是子类继承父类的关系
4. // 可以是不同的类或不是自己的类
5. // 可以是自己的类
7. class Person
8. {
9. public:
10.         /*virtual A* BuyTicket()
11.         {
12.                 cout << "买票-全价" << endl;
13.                 return nullptr;
14.         }*/
15.         virtual Person* BuyTicket()
16.         {
17.                 cout << "买票-全价" << endl;
18.                 return nullptr;
19.         }
20. };
22. class Student : public Person
23. {
24. public:
25.         /*virtual B* BuyTicket()
26.         {
27.                 cout << "买票-打折" << endl;
28.                 return nullptr;
29.         }*/
30.         virtual Student* BuyTicket()
31.         {
32.                 cout << "买票-打折" << endl;
33.                 return nullptr;
34.         }
35. };
37. void Func(Person* ptr)
38. {
39.         ptr->BuyTicket();
40. }
42. int main()
43. {
44.         Person ps;
45.         Student st;
47.         Func(&ps);
48.         Func(&st);
50.         return 0;
51. }

复制代码

析构函数的重写

• 父类的析构函数为虚函数，此时子类析构函数只要定义，无论是否加virtual关键字，都与父类的析构函数构成重写，虽然父类与子类析构函数名字差别看起来不符合重写的规则，现实上编译器对析构函数的名称做了特殊处置惩罚，编译后析构函数的名称同一处置惩罚成destructor，所以父类的析构函数加了vialtual修饰，子类的析构函数就构成重写。
  

1. // 析构函数的名字会被特殊处理为destructor
2. // 变相的符合了3重
3. class A
4. {
5. public:
6.         virtual ~A()
7.         {
8.                 cout << "~A()" << endl;
9.         }
10. };
12. class B : public A
13. {
14. public:
15.         ~B()
16.         {
17.                 cout << "~B()->delete:" << _p << endl;
18.                 delete _p;
19.         }
20. protected:
21.         int* _p = new int[10];
22. };
24. // 只有派生类Student的析构函数重写了Person的析构函数，下⾯的delete对象调⽤析构函数，才能
25. // 构成多态，才能保证p1和p2指向的对象正确的调用析构函数。
27. int main()
28. {
29.         // 父类的指针指向子类,根据指向的对象调用析构函数
30.         // 不构成多态,会根据父类的类型调用两次A类
31.         // 不构成多态存在内存泄漏的问题
32.         A* p1 = new A;
33.         A* p2 = new B;
35.         // p1->destructor() + operator delete(free)
36.         delete p1;
37.         delete p2;
39.         return 0;
40. }

复制代码

为什么会调用两次A类的析构？
因为B类继续了A类，B类的析构竣事会自动调用A类的析构

所以继续那边构成~A构成函数隐藏，为什么构成函数隐藏，因为处置惩罚后函数名雷同（destructor），为什么函数名雷同，因为多态这里为了防止内存走漏，为了构成虚函数，指向的对象差别调用A和B类的析构

1. class A
2. {
3. public:
4.         ~A()
5.         {
6.                 cout << "~A()" << endl;
7.         }
8. };
10. class B : public A
11. {
12. public:
13.         ~B()
14.         {
15.                 cout << "~B()->delete:" << _p << endl;
16.                 delete _p;
17.         }
18. protected:
19.         int* _p = new int[10];
20. };

复制代码

override和final关键字

• C++11新增的关键字，override用来检查是否构成重写，因为编译器在编译阶段是检查不出来的，在运行时才能检查出来，加override是为了在编译时就检查出来
  

1. class Car
2. {
3. public:
4.         virtual void Dirve()
5.         {}
6. };
8. class Benz :public Car
9. {
10. public:
11.         virtual void Drive() override { cout << "Benz-舒适" << endl; }
12. };

复制代码

• 假如我们不想在子类重写这个虚函数，用final修饰，不能被重写
  

1. class Car
2. {
3. public:
4. virtual void Drive() final {}
5. };
7. class Benz :public Car
8. {
9. public:
10. virtual void Drive() { cout << "Benz-舒适" << endl; }
11. };

复制代码

• 继续那边的final，作用是修饰为最终类，不能被继续
  

1. class Car final
2. {
3. public:
4. virtual void Drive() final {}
5. };

复制代码

重载/重写/隐藏的对比

纯虚函数和抽象类

• 在虚函数后面写上=0就是纯虚函数，纯虚函数不需要定义实现（现实上没有什么意义因为要被子类重写，重写之后父类的实现就没用了，但是语法上支持定义实现），只要声明即可。包罗纯虚函数的类叫做抽象类，抽象类不能被实例化出对象，假如子类继续后不重写纯虚函数，那么子类也是抽象类。纯虚函数在某种程度上欺压了子类重写虚函数，因为不重写实例化不出对象。
  

1. class Car
2. {
3. public:
4.         virtual void Drive() = 0;
5. };
7. class Benz :public Car
8. {
9. public:
10.         virtual void Drive()
11.         {
12.                 cout << "Benz-舒适" << endl;
13.         }
14. };
16. class BMW :public Car
17. {
18. public:
19.         virtual void Drive()
20.         {
21.                 cout << "BMW-操控" << endl;
22.         }
23. };
25. int main()
26. {
27.         // 父类无法实例化出对象
28.         // 但是可以用指针和引用来实现多态
29.         // Car c;
31.         Car* pBenz = new Benz;
32.         pBenz->Drive();
34.         Car* pBMW = new BMW;
35.         pBMW->Drive();
37.         return 0;
38. }

复制代码

多态是一种相对的概念，B既可以是父类也可以是子类

多态的原理

虚函数表指针

有几个虚函数就有几个虚函数表指针
虚函数表指针指向一个函数指针数组

指向谁就调用谁，指向哪个对象就到那个对象的虚函数表中找到对应的函数，进行调用

1. class Person
2. {
3. public:
4.         virtual void BuyTicket()
5.         {
6.                 cout << "买票-全价" << endl;
7.         }
8. private:
9.         string _name;
10. };
12. class Student : public Person
13. {
14. public:
15.         virtual void BuyTicket()
16.         {
17.                 cout << "买票-打折" << endl;
18.         }
19. private:
20.         string _id;
21. };
23. class Soldier : public Person
24. {
25. public:
26.         virtual void BuyTicket()
27.         {
28.                 cout << "买票-优先" << endl;
29.         }
30. private:
31.         string _codename;
32. };
34. void Func(Person* ptr)
35. {
36.         // 这⾥可以看到虽然都是Person指针Ptr在调⽤BuyTicket
37.         // 但是跟ptr没关系，⽽是由ptr指向的对象决定的。
38.         ptr->BuyTicket();
39. }
41. int main()
42. {
43.         // 其次多态不仅仅发生在子类对象之间，多个子类继承父类，重写虚函数后
44.         // 多态也会发生在多个子类之间。
45.         Person ps;
46.         Student st;
47.         Soldier sr;
49.         Func(&ps);
50.         Func(&st);
51.         Func(&sr);
53.         return 0;
54. }

复制代码

动态绑定和静态绑定

• 动态绑定是根据指向的对象决定（满意多态）
  满意多态条件的函数调⽤是在运行时绑定，也就是在运行时到指向对象的虚函数表中找到调用函数
  的地址，也就做动态绑定。运行时去找
  
• 静态绑定是根据类型决定（不满意多态）
  对不满意多态条件(指针大概引用+调用虚函数)的函数调用是在编译时绑定，也就是编译时确定调用函数的地址，叫做静态绑定。静态绑定的服从更高一点
  
  
  
  

虚函数表

• 有几个虚函数就放几个虚函数的地址到虚函数表中
  
• 同类型的对象虚函数表是一样的，差别类型对象虚表各自独立
  
  
  
  
• 子类由两部分构成，继续下来的父类和本身的成员，⼀般情况下，继续下来的父类中有虚函数表
  指针，本身就不会再天生虚函数表指针。但是要注意的这⾥继续下来的父类部分虚函数表指针和父
  类对象的虚函数表指针不是同⼀个，就像父类对象的成员和子类对象中的父类对象成员也独立的。
  
• 子类中重写的父类的虚函数，原来是把父类的虚函数的地址拷贝了下来，但是重写了，就覆盖了父类的虚函数的地址
  
• 子类的虚函数表中包罗三个部分：
  (1)父类的虚函数地址
  (2)子类重写的虚函数地址完成覆盖
  (3)子类本身的虚函数地址
  

6. 虚函数表本质是⼀个存虚函数指针的指针数组（虚函数指针数组），⼀般情况这个数组最后面放了⼀个0x00000000标记。vs有规定，gcc没有规定
7. 虚函数存在哪的？虚函数和普通函数⼀样的，编译好后是⼀段指令，都是存在代码段的，只是虚函数的地址（指针）又存到了虚表中。
8. 虚函数表存在哪的？这个问题严格说并没有标准答案C++标准并没有规定，我们写下面的代码可以对比验证⼀下。vs下是存在代码段(常量区)

1. class Base
2. {
3. public:
4.         virtual void func1() { cout << "Base::func1" << endl; }
5.         virtual void func2() { cout << "Base::func2" << endl; }
6.         void func5() { cout << "Base::func5" << endl; }
7. protected:
8.         int a = 1;
9. };
11. class Derive : public Base
12. {
13. public:
14.         // 重写基类的func1
15.         virtual void func1() { cout << "Derive::func1" << endl; }
16.         virtual void func3() { cout << "Derive::func1" << endl; }
17.         void func4() { cout << "Derive::func4" << endl; }
18. protected:
19.         int b = 2;
20. };
22. //int main()
23. //{
24. //        Base b;
25. //        Derive d;
26. //
27. //        return 0;
28. //}
30. int main()
31. {
32.         int i = 0;
33.         static int j = 1;
34.         int* p1 = new int;
35.         const char* p2 = "xxxxxxxx";
37.         printf("栈:%p\n", &i);
38.         printf("静态区:%p\n", &j);
39.         printf("堆:%p\n", p1);
40.         printf("常量区:%p\n", p2);
42.         Base b;
43.         Derive d;
44.         Base* p3 = &b;
45.         Derive* p4 = &d;
47.         // %p对象就是地址
48.         printf("Person虚表地址:%p\n", *(int*)p3);
49.         printf("Student虚表地址:%p\n", *(int*)p4);
50.         printf("虚函数地址:%p\n", &Base::func1);
51.         printf("普通函数地址:%p\n", &Base::func5);
53.         return 0;
54. }

复制代码

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