• 【c++】多态

    多态的概念

    • 多态，顾名思义就是多种形态。再通俗一点，就是去完成某个行为，不同的对象去完成时会产生出不同的状态

    • 比如我们去车站买票，当你是学生时能买到半价票，当你是普通人时买到的是全价票，这便是完成统一行为所产生的多种形态

    • c++中的多态：多态是不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如我们让student类去继承person类，person对象买全价票，student对象买半价票

    多态的定义以及实现

    多态构成的条件

    • 在程序中我们该如何实现多态呢？首先要知道构成多态的条件要哪些

    • 继承中构成多态的条件：

    1. 必须使用基类的引用或指针去调用虚函数

    2. 被调用的函数必须是虚函数

    3. 派生类必须完成对基类对象的虚函数重写

    • 代码演示：

    1. #include<iostream>
    2.  
    3. using namespace std;
    4.  
    5. class Person
    6. {
    7. public:
    8.     //被调用的函数必须是虚函数
    9.  virtual void buyticket()
    10.  {
    11.   cout << "买全价票" << endl;
    12.  }
    13. };
    14.  
    15. class Student : public Person
    16. {
    17. public:
    18.     //对基类的虚函数进行重写
    19.  virtual void buyticket()
    20.  {
    21.   cout << "买半价票" << endl;
    22.  }
    23. };
    24. int main()
    25. {
    26.  Person* per;
    27.  
    28.  Student stu;
    29.  per = &stu;
    30.     
    31.     //用基类的指针去调用
    32.  per->buyticket();
    33.  return 0;
    34. }

    虚函数

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

    1.  //被调用的函数必须是虚函数
    2.  virtual void buyticket()
    3.  {
    4.   cout << "买全价票" << endl;
    5.  }

    虚函数的重写（覆盖）

    • 派生类中有一个和基类完全相同的虚函数（返回值、函数名、参数都相同），称为派生类重写了基类的虚函数。

    1. class Person
    2. {
    3. public:
    4.     //被调用的函数必须是虚函数
    5.  virtual void buyticket()
    6.  {
    7.   cout << "买全价票" << endl;
    8.  }
    9. };
    10.  
    11. class Student : public Person
    12. {
    13. public:
    14.     //对基类的虚函数进行重写
    15.  virtual void buyticket()
    16.  {
    17.   cout << "买半价票" << endl;
    18.  }
    19. };

    • 派生类的虚函数重写，继承的是基类的接口声明，重写的是实现。例如当基类和派生类的缺省值不同，实际上用的是基类的缺省值

    • 注意：在重写基类的虚函数时，子类的虚函数不加virtual也能构成重写，但这种写法并不规范，应该尽量避免

    虚函数重写的两个例外

    • 协变（基类和派生类的返回值类型不同）：指的是基类虚函数返回的是基类对象的引用或者指针，派生类虚函数返回的是派生类对象的指针或引用

    1. class A{};
    2. class B : public A {};
    3. class Person {
    4. public:
    5.  virtual A* f() {return new A;}
    6. };
    7. class Student : public Person {
    8. public:
    9.  virtual B* f() {return new B;}
    10. };

    • 析构函数的重写（基类和派生类）：指的是基类的析构函数和派生类的析构函数名字不同。如果基类的析构函数是虚函数，只要派生类定义了析构函数，其析构函数无论是否加virtual修饰，都与基类的析构函数构成重写。这是由于编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。

    1. class Person {
    2. public:
    3.  virtual ~Person() {cout << "~Person()" << endl;}
    4. };
    5. class Student : public Person {
    6. public:
    7.  virtual ~Student() { cout << "~Student()" << endl; }
    8. };
    9. // 只有派生类Student的析构函数重写了Person的析构函数，下面的delete对象调用析构函
    10. 数，才能构成多态，才能保证p1和p2指向的对象正确的调用析构函数。

    • 析构函数重写的作用，保证使用父类指针销毁子类对象不会造成内存泄露

    1. #include<iostream>
    2.  
    3. using namespace std;
    4.  
    5. class Person {
    6. public:
    7.  virtual ~Person() { cout << "~Person()" << endl; }
    8. };
    9. class Student : public Person {
    10. public:
    11.  virtual ~Student() { cout << "~Student()" << endl; }
    12. };
    13.  
    14.  
    15.  
    16. int main()
    17. {
    18.  //Person per;
    19.  
    20.  //Student stu;
    21.  
    22.  
    23.  //buyticker(per);
    24.  //cout << endl;
    25.  //buyticker(stu);
    26.  
    27.  Person* p1 = new Person;
    28.  Person* p2 = new Student;
    29.  
    30.  delete p1;
    31.  delete p2;
    32.  return 0;
    33. }

    • 析构函数构成重写，使用基类指针去销毁派生类对象时，派生类对象会先调用自己的析构，再调用父类的析构（先子后父）

    • 否则：会导致内存泄漏问题，先销毁了基类却并没有销毁子类

    普通调用和多态调用的区别

    • 普通调用：传参传的是谁，就谁的函数。

    • 多台调用：父类指针指向谁，就调用谁的函数。

    1. #include<iostream>
    2.  
    3. using namespace std;
    4.  
    5. class Person
    6. {
    7. public:
    8.  virtual void buyticket()
    9.  {
    10.   cout << "买全价票" << endl;
    11.  }
    12. };
    13.  
    14. class Student : public Person
    15. {
    16. public:
    17.  virtual void buyticket()
    18.  {
    19.   cout << "买半价票" << endl;
    20.  }
    21. };
    22. //多态调用
    23. void buyticker(Person& people)
    24. {
    25.  people.buyticket();
    26. }
    27.  
    28. int main()
    29. {
    30.  Person per;
    31.  
    32.  Student stu;
    33.  
    34.  
    35.  buyticker(per);
    36.  cout << endl;
    37.     
    38.     //虽然参数类型是person&，但调用的是student中的买票函数
    39.     //如果是普通调用，则只会调person类的买票函数
    40.  buyticker(stu);
    41.  return 0;
    42. }

    c++11标准中的 override和final

    • final：修饰虚函数，表示该虚函数不能再被重写。（继承那篇文章提到过，修饰类表示类不可被继承继承）

    • override：检查派生类虚函数是否重写了基类某个虚函数，如果没有重写则编译报错

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

    重载、重写、重定义的比较

    抽象类

    纯虚函数

    • 在虚函数后面加上=0，就称这个函数为纯虚函数

    1.  virtual void Drive()=0
    2.  {}

    抽象类概念

    • 概念： 包含纯虚函数的类就叫抽象类（也叫接口类）

    • 特点：

    1. 抽象类不能实例化出对象

    2. 派生类继承抽象类之后也不能实例化出对象

    3. 除非派生类重写纯虚函数

    4. 纯虚函数规范了哌省内必须重写，另外纯虚函数更体现出了接口继承

    1. class Car
    2. {
    3. public:
    4. virtual void Drive() = 0;
    5. };
    6. class Benz :public Car
    7. {
    8. public:
    9.  virtual void Drive()
    10.  {
    11.  cout << "Benz-舒适" << endl;
    12.  }
    13. };
    14. class BMW :public Car
    15. {
    16. public:
    17.  virtual void Drive()
    18.  {
    19.  cout << "BMW-操控" << endl;
    20.  }
    21. };
    22. void Test()
    23. {
    24. Car* pBenz = new Benz;
    25.  pBenz->Drive();
    26.  Car* pBMW = new BMW;
    27.  pBMW->Drive();
    28. }

    接口继承和实现继承对比

    • 实现继承：常见的有普通函数继承，派生类继承了基类函数的实现

    • 接口继承：虚函数的继承，派生类继承了基类函数的接口声明，重写了实现。目的是为了重写，重写是为了实现多态。

    • 如果不实现多态，不要把函数定义成虚函数

    多态的原理

    虚函数表

    • 先看一个问题，下面对象的大小是多少？

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

    • 答案：

    • 为什么呢？不是只有一个私有成员吗？不应该是4吗？我们通过监视去看看

    • 除了私有成员_b之外还有一个__vfptr指针，这下我们知道8是怎么来的了，那么__vfptr指针是什么？我们关它叫虚函数表指针（(v代表virtual，f代表function)）一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表

    • 派生类当中是个什么情况呢？

    1. class Base
    2. {
    3. public:
    4.  virtual void Func1()
    5.  {
    6.   cout << "Base::Func1()" << endl;
    7.  }
    8.  virtual void Func2()
    9.  {
    10.   cout << "Base::Func2()" << endl;
    11.  }
    12.  void Func3()
    13.  {
    14.   cout << "Base::Func3()" << endl;
    15.  }
    16. private:
    17.  int _b = 1;
    18. };
    19. class Derive : public Base
    20. {
    21. public:
    22.  virtual void Func1()
    23.  {
    24.   cout << "Derive::Func1()" << endl;
    25.  }
    26. private:
    27.  int _d = 2;
    28. };
    29. int main()
    30. {
    31.  Base b;
    32.  Derive d;
    33.  return 0;
    34. }
    35.

    • 通过监视窗口去观察我们可以发现：

    1. 派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员，虚表指针也就是存在部分的另一部分是自己的成员。

    2. 基类b对象和派生类d对象虚表是不一样的，这里我们发现Func1完成了重写，所以d的虚表中存的是重写的Derive::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。

    3. 另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函数，所以不会放进虚表。

    4. 虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个nullptr。

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

    6. 虚函数存在哪的？虚表存在哪的？ 注意虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。

    多态的原理

    • 还是之前买票的例子

    1. class Person {
    2. public:
    3.  virtual void BuyTicket() { cout << "买票-全价" << endl; }
    4. };
    5. class Student : public Person {
    6. public:
    7.  virtual void BuyTicket() { cout << "买票-半价" << endl; }
    8. };
    9. void Func(Person& p)
    10. {
    11. p.BuyTicket();
    12. }
    13. int main()
    14. {
    15. Person Mike;
    16.  Func(Mike);
    17. Student Johnson;
    18. Func(Johnson);
    19.  return 0;
    20. }

    • 依然是借助监视窗口研究

    1. 观察下图的红色箭头我们看到，p是指向mike对象时，p->BuyTicket在mike的虚表中找到虚函数是Person::BuyTicket。

    2. 观察下图的蓝色箭头我们看到，p是指向johnson对象时，p->BuyTicket在johson的虚表中找到虚函数是Student::BuyTicket。

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

    4. 反过来思考我们要达到多态，有两个条件，一个是虚函数覆盖，一个是对象的指针或引用调用虚函数。反思一下为什么？

    5. 再通过下面的汇编代码分析，看出满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象的中取找的。不满足多态的函数调用时编译时确认好的

    • 借助汇编进一步探查

    1. void Func(Person* p)
    2. {
    3. ...
    4.  p->BuyTicket();
    5. // p中存的是mike对象的指针，将p移动到eax中
    6. 001940DE  mov         eax,dword ptr [p]
    7. // [eax]就是取eax值指向的内容，这里相当于把mike对象头4个字节(虚表指针)移动到了edx
    8. 001940E1  mov         edx,dword ptr [eax]
    9. // [edx]就是取edx值指向的内容，这里相当于把虚表中的头4字节存的虚函数指针移动到了eax
    10. 00B823EE  mov         eax,dword ptr [edx]
    11. // call eax中存虚函数的指针。这里可以看出满足多态的调用，不是在编译时确定的，是运行起来
    12. 以后到对象的中取找的。
    13. 001940EA  call        eax  
    14. 00头1940EC  cmp         esi,esp  
    15. }
    16. int main()
    17. {
    18. ... 
    19. // 首先BuyTicket虽然是虚函数，但是mike是对象，不满足多态的条件，所以这里是普通函数的调
    20. 用转换成地址时，是在编译时已经从符号表确认了函数的地址，直接call 地址
    21.  mike.BuyTicket();
    22. 00195182  lea         ecx,[mike]
    23. 00195185  call        Person::BuyTicket (01914F6h)  
    24. ... 
    25. }

    动态绑定和静态绑定

    • 静态绑定：又被称为前期绑定（早绑定）在程序编译期间确定了程序的行为，也叫作静态多态，如函数的重载

    • 动态绑定又称为后期绑定（晚绑定），是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也被称作动态多态

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

    单继承中多个虚函数表

    1. class Base {
    2. public:
    3.  virtual void func1() { cout << "Base::func1" << endl; }
    4.  virtual void func2() { cout << "Base::func2" << endl; }
    5. private:
    6.  int a;
    7. };
    8. class Derive :public Base {
    9. public:
    10.  virtual void func1() { cout << "Derive::func1" << endl; }
    11.  virtual void func3() { cout << "Derive::func3" << endl; }
    12.  virtual void func4() { cout << "Derive::func4" << endl; }
    13. private:
    14.  int b;
    15. };
    16.  
    17. int main()
    18. {
    19.  Base b;
    20.  Derive d;
    21.  
    22.  return 0;
    23. }

    • 我们看下图会有一个疑问：fun3和fun4呢？没放进虚表里面吗？其实不然，每一个虚函数一定会被放进虚表里面，只是监视窗口欺骗了我们，我们需要通过内存窗口去观察。

    • b中的内存示意

    • d中的内存示意

    • 可以看见b中的虚表存了两个虚函数指针，d中的虚表存了4个虚函数指针，其中重写了fun1，继承了func2，自己有fun3、fun4

    • 内存可能有些难看，我们还是用打印的方法吧~

    1. typedef void(*VFPTR) ();//定义一个虚函数指针
    2. void PrintVTable(VFPTR vTable[])
    3. {
    4.  // 依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数
    5.  cout << " 虚表地址>" << vTable << endl;
    6.  for (int i = 0; vTable[i] != nullptr; ++i)
    7.  {
    8.   printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
    9.   VFPTR f = vTable[i];
    10.   f();
    11.  }
    12.  cout << endl;
    13. }
    14. int main()
    15. {
    16.  Base b;
    17.  Derive d;
    18.  // 思路：取出b、d对象的头4bytes，就是虚表的指针，前面我们说了虚函数表本质是一个存虚函数指针的指针数组，这个数组最后面放了一个nullptr
    19.  // 1.先取b的地址，强转成一个int*的指针
    20.  // 2.再解引用取值，就取到了b对象头4bytes的值，这个值就是指向虚表的指针
    21.  // 3.再强转成VFPTR*，因为虚表就是一个存VFPTR类型(虚函数指针类型)的数组。
    22.  // 4.虚表指针传递给PrintVTable进行打印虚表
    23.  // 5.需要说明的是这个打印虚表的代码经常会崩溃，因为编译器有时对虚表的处理不干净，虚表最后面没有放nullptr，导致越界，这是编译器的问题。我们只需要点目录栏的 - 生成 - 清理解决方案，再编译就好了。
    24.  VFPTR* vTableb = (VFPTR*)(*(int*)&b);
    25.  PrintVTable(vTableb);
    26.  VFPTR* vTabled = (VFPTR*)(*(int*)&d);
    27.  PrintVTable(vTabled);
    28.  return 0;
    29. }

    • 以上就是单继承中的虚函数表

    多继承中的虚函数表

    • 这次就不看内存了，直接打印出来给大家看吧

    1. class Base1 {
    2. public:
    3.  virtual void func1() { cout << "Base1::func1" << endl; }
    4.  virtual void func2() { cout << "Base1::func2" << endl; }
    5. private:
    6.  int b1;
    7. };
    8. class Base2 {
    9. public:
    10.  virtual void func1() { cout << "Base2::func1" << endl; }
    11.  virtual void func2() { cout << "Base2::func2" << endl; }
    12. private:
    13.  
    14.  int b2;
    15. };
    16. class Derive : public Base1, public Base2 {
    17. public:
    18.  virtual void func1() { cout << "Derive::func1" << endl; }
    19.  virtual void func3() { cout << "Derive::func3" << endl; }
    20. private:
    21.  int d1;
    22. };
    23. typedef void(*VFPTR) ();
    24. void PrintVTable(VFPTR vTable[])
    25. {
    26.  cout << " 虚表地址>" << vTable << endl;
    27.  for (int i = 0; vTable[i] != nullptr; ++i)
    28.  {
    29.   printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
    30.   VFPTR f = vTable[i];
    31.   f();
    32.  }
    33.  cout << endl;
    34. }
    35. int main()
    36. {
    37.  Derive d;
    38.  VFPTR* vTableb1 = (VFPTR*)(*(int*)&d);
    39.  PrintVTable(vTableb1);
    40.  VFPTR* vTableb2 = (VFPTR*)(*(int*)((char*)&d + sizeof(Base1)));
    41.  PrintVTable(vTableb2);
    42.  return 0;
    43. }

    • 从上图可以看出，多继承派生类的未重写的虚函数放在第一个继承基类部分

    菱形继承、菱形虚拟继承

    • 实际中我们不建议设计出菱形继承及菱形虚拟继承，一方面太复杂容易出问题，另一方面这样的模型，访问基类成员有一定得性能损耗。所以菱形继承、菱形虚拟继承我们的虚表我们就不看了，一般我们也不需要研究清楚，因为实际中很少用。如果同志们很感兴趣，可以去看下面的两篇链接文章。

    C++ 虚函数表解析

    C++ 对象的内存布局

    一些要注意的问题

    • inline函数能是虚函数吗？答：可以不过编译器会忽略调inline属性，这个函数不再是inline，因为虚函数都要放在虚表里面

    • 静态成员函数能是虚函数吗？答：不可以，静态成员函数没有this指针，使用类型：：成员函数的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数。

    • 构造函数能是虚函数吗？答：不可以，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。这就变成鸡生蛋和蛋生鸡问题了（虚函数的调用要通过虚函数表找到虚函数指针，而虚函数表的指针是在初始化列表阶段才初始化的）

    • 虚函数表是在什么时候生成？存在哪？答：虚函数表是在编译阶段生成的，一般情况下存在代码区（常量区）

  • 相关阅读:
    linux安装mysql8.0
    MATLAB 软件功能简介
    使用php实现pc端和移动端分离
    JAVA计算机毕业设计药品管理系统Mybatis+系统+数据库+调试部署
    吴恩达机器学习-可选的实验室-正则化成本和梯度（Regularized Cost and Gradient）
    【连通性的初步分析】
    Python基础095：Python读取PDF中的字符
    K-verse 小型活动来袭！
    unity unityWebRequest 通过http下载服务器资源
    Codeforces Round #833 (Div. 2) A-D.md
  • 原文地址：https://blog.csdn.net/ZHENGZJM/article/details/134059127