• C++ 多态

    目录

    一.多态的概念及实现

    1.概念 

    2.多态构成条件

    3.虚函数

    4.虚函数的重写（覆盖）

    5.C++11 final和override

    （1）final

    （2）override

    二.重载、重定义（隐藏）、重写（覆盖）对比

    1.重载

    2.重定义（隐藏）

    3.重写（覆盖）

    三.抽象类

    1.概念

    2.接口继承和实现继承

    四.多态的原理

    1.虚函数表

    2.多态的原理

    3.静态绑定与动态绑定

    （1）静态绑定

    （2）动态多态

    五.单继承和多继承中的虚函数表

    1.单继承中的虚函数表

    2.多继承中的虚函数表

    前言：继上一个继承，多态又是面向对象的一大特性。

    一.多态的概念及实现

    1.概念 

           多态，通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时回产生出不同的状态。

    2.多态构成条件

            多态时在不同继承关系的类对象，去调用同一函数时，产生了不同的行为。

            而在继承中要构成多态还有两个条件：

    ① 必须通过基类的指针或引用调用虚函数。

    ② 被调用的函数必须时是虚函数，且派生类必须对基类的虚函数进行重写。

    3.虚函数

    虚函数：即被virtual修饰的类成员函数。

    1. class Person {
    2. public:
    3.     virtual void Test() 
    4.     { 
    5.         cout << "virtual" << endl;
    6.     }
    7. };

    4.虚函数的重写（覆盖）

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

           

            虚函数重写：语法层的概念。派生类对继承基类虚函数实现了重写。

            虚函数覆盖： 原理层的概念。派生类的虚表，拷贝基类的虚表进行了修改，覆盖重写了那个虚函数。

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

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

    虚函数重写的两个例外：

    （1）协变（基类与派生类虚函数返回值类型不同）

            派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或引用，派生类虚函数返回派生类对象的指针或引用时，称为协变。

    1. class A
    2. {};
    3.  
    4. class B : public A 
    5. {};
    6.  
    7. class Person {
    8. public:
    9.     virtual A* f() 
    10.     {
    11.         return new A;
    12.     }
    13. };
    14.  
    15. class Student : public Person 
    16. {
    17. public:
    18.     virtual B* f() 
    19.     {
    20.         return new B;
    21.     }
    22. };

            A*和B*的返回值类型不同，基类返回基类的指针A*；派生类返回派生类的指针B*，所以构成重写，即发生协变。

    （2）析构函数的重写（基类与派生类析构函数的名字不同）

            如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写。虽然基类与派生类名字不同，看起来违背了重写的规则，但是实际上这里编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理称destructor。

    1. class Person {
    2. public:
    3.     virtual ~Person() 
    4.     {
    5.         cout << "~Person()" << endl;
    6.     }
    7. };
    8.  
    9. class Student : public Person {
    10. public:
    11.     virtual ~Student() 
    12.     { 
    13.         cout << "~Student()" << endl; 
    14.     }
    15. };
    16.  
    17. // 只有派生类Student的析构函数重写了Person的析构函数，下面的delete对象调用析构函
    18. 数，才能构成多态，才能保证p1和p2指向的对象正确的调用析构函数
    19. int main()
    20. {
    21.     Person* p1 = new Person;
    22.     Person* p2 = new Student;
    23.     delete p1;
    24.     delete p2;
    25.     return 0;
    26. }

    5.C++11 final和override

            C++对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名 字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结构才会发现。因此，C++11提供了final和override两个关键字，可以帮助用户检测是否重写。

    （1）final

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

    1. class Car
    2. {
    3. public:
    4.     virtual void Drive() final 
    5.     {}
    6. };
    7.  
    8. class Benz :public Car
    9. {
    10. public:
    11.     virtual void Drive() 
    12.     {
    13.         cout << "Benz" << endl;
    14.     }
    15. };

    （2）override

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

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

    二.重载、重定义（隐藏）、重写（覆盖）对比

    1.重载

    ① 两个函数在同一作用域

    ② 函数名/参数相同

    2.重定义（隐藏）

    ① 两个函数分别在基类和派生类的作用域

    ② 函数名相同

    ③ 两个基类和派生类的同名函数不构成重写就是重定义

    3.重写（覆盖）

    ① 两个函数分别在基类和派生类的作用域

    ② 函数名/参数/返回值都必须相同（协变例外）

    ③ 两个函数必须是虚函数

    三.抽象类

    1.概念

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

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

    2.接口继承和实现继承

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

    四.多态的原理

    1.虚函数表

    看这样一道题：sizeof(Base)是多少？ 

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

            这里在x32位平台下，结果是8字节。除了_b成员，还有个vfptr放在对象的前面（有些平台是放到对象的后面），对象中的这个指针我们叫做虚函数表指针（v代表virtual，f代表function）。一个含有虚函数的类中都至少有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。那么派生类中这个表放的是什么呢？

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

    由上面的图和测试可知：

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

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

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

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

    总结派生类的虚表生成：

            a. 先将基类中的虚表内容拷贝一份到派生类虚表中。

            b. 如果派生类重写了基类中的某个虚函数，就用派生类自己的虚函数覆盖虚表中基类的虚函数。

            c. 派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。

     注意：“虚函数存在虚表，虚表存在对象中”，这句话是错的。

            虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样，都是存在代码段的，只是它的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。而虚表通过验证是存在代码段的。

    2.多态的原理

     

            通过测试我们可以知道，多态的实现是在运行时，去指向对象的虚表中调用函数地址的。

            满足多态的函数调用，是运行时决议的，不满足多态的普通函数调用，是编译时决议的。


    我们再思考一个问题，基类赋值给派生类时，也可以切片，但为什么实现不了多态呢？

    3.静态绑定与动态绑定

    （1）静态绑定

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

    （2）动态多态

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

    五.单继承和多继承中的虚函数表

    1.单继承中的虚函数表

    1. class Base
    2. {
    3. public:
    4. 	virtual void Func1()
    5. 	{
    6. 		cout << "Base::Func1()" << endl;
    7. 	}
    8.  
    9. 	virtual void Func2()
    10. 	{
    11. 		cout << "Base::Func2()" << endl;
    12. 	}
    13.  
    14. 	void Func3()
    15. 	{
    16. 		cout << "Base::Func3()" << endl;
    17. 	}
    18.  
    19. private:
    20. 	int _b = 1;
    21. };
    22.  
    23. class Derive : public Base
    24. {
    25. public:
    26. 	// 重写
    27. 	virtual void Func1()
    28. 	{
    29. 		cout << "Derive::Func1()" << endl;
    30. 	}
    31.  
    32. 	void Func3()
    33. 	{
    34. 		cout << "Derive::Func3()" << endl;
    35. 	}
    36.  
    37. 	virtual void Func4()
    38. 	{
    39. 		cout << "Derive::Func4()" << endl;
    40. 	}
    41. private:
    42. 	int _d = 2;
    43. };
    44.  
    45. // 取内存值，打印并调用，确认是否是func4
    46. //typedef void(*)() V_FUNC; // 不支持
    47. typedef void(*V_FUNC)();
    48.  
    49. // 打印虚表
    50. //void PrintVFTable(V_FUNC a[])
    51. void PrintVFTable(V_FUNC* a)
    52. {
    53. 	printf("vfptr:%p\n", a);
    54.  
    55. 	for (size_t i = 0; a[i] != nullptr; ++i)
    56. 	{
    57. 		printf("[%d]:%p->", i, a[i]);
    58. 		V_FUNC f = a[i];
    59. 		f();
    60. 	}
    61. }
    62.  
    63. int c = 2;
    64.  
    65. int main()
    66. {
    67. 	Base b;
    68. 	Derive d;
    69. 	PrintVFTable((V_FUNC*)(*((int*)&d)));
    70.  
    71.     return 0;
    72. }

            在vs中通过观察监视窗口是看不到Fun3和Fun4的。那么我们就要使用内存窗口以及打印对比的方式来测试。

    PrintVFTable((V_FUNC*)(*((int*)&d)));

            先取d的地址，强转成int*的指针（int类型和指针类型不能转，但是指针类型可以随便转），再解引用取值，就取到了d对象头4字节的值，这个值就是指向虚表的指针（指针是4字节的）。最后再强转为V_FUNC*类型传给PrintVFTable进行打印虚表。

            我们再测试一下虚表到底存放在哪：

    1. class Base
    2. {
    3. public:
    4. 	virtual void Func1()
    5. 	{
    6. 		cout << "Base::Func1()" << endl;
    7. 	}
    8.  
    9. 	virtual void Func2()
    10. 	{
    11. 		cout << "Base::Func2()" << endl;
    12. 	}
    13.  
    14. 	void Func3()
    15. 	{
    16. 		cout << "Base::Func3()" << endl;
    17. 	}
    18.  
    19. private:
    20. 	int _b = 1;
    21. };
    22.  
    23. class Derive : public Base
    24. {
    25. public:
    26. 	// 重写
    27. 	virtual void Func1()
    28. 	{
    29. 		cout << "Derive::Func1()" << endl;
    30. 	}
    31.  
    32. 	void Func3()
    33. 	{
    34. 		cout << "Derive::Func3()" << endl;
    35. 	}
    36.  
    37. 	virtual void Func4()
    38. 	{
    39. 		cout << "Derive::Func4()" << endl;
    40. 	}
    41. private:
    42. 	int _d = 2;
    43. };
    44.  
    45. // 取内存值，打印并调用，确认是否是func4
    46. //typedef void(*)() V_FUNC; // 不支持
    47. typedef void(*V_FUNC)();
    48.  
    49. // 打印虚表
    50. //void PrintVFTable(V_FUNC a[])
    51. void PrintVFTable(V_FUNC* a)
    52. {
    53. 	printf("vfptr:%p\n", a);
    54.  
    55. 	for (size_t i = 0; a[i] != nullptr; ++i)
    56. 	{
    57. 		printf("[%d]:%p->", i, a[i]);
    58. 		V_FUNC f = a[i];
    59. 		f();
    60. 	}
    61. }
    62.  
    63. int c = 2;
    64.  
    65. int main()
    66. {
    67. 	// 虚表，一个类型，一个虚表，所以这个类型对象都存这个虚表指针
    68. 	Base b1;
    69. 	Base b2;
    70. 	Base b3;
    71. 	Base b4;
    72. 	PrintVFTable((V_FUNC*)(*((int*)&b1)));
    73. 	PrintVFTable((V_FUNC*)(*((int*)&b2)));
    74. 	PrintVFTable((V_FUNC*)(*((int*)&b3)));
    75. 	PrintVFTable((V_FUNC*)(*((int*)&b4)));
    76.  
    77. 	int a = 0;
    78. 	static int b = 1;
    79. 	const char* str = "hello world";
    80. 	int* p = new int[10];
    81. 	printf("栈：%p\n", &a);
    82. 	printf("静态区/数据段：%p\n", &b);
    83. 	printf("静态区/数据段：%p\n", &c);
    84. 	printf("常量区/代码段：%p\n", str);
    85. 	printf("堆：%p\n", p);
    86. 	printf("虚表：%p\n", (*((int*)&b4)));
    87. 	printf("函数地址：%p\n", &Derive::Func3);
    88. 	printf("函数地址：%p\n", &Derive::Func2);
    89. 	printf("函数地址：%p\n", &Derive::Func1);
    90.  
    91. 	return 0;
    92. }

            通过测试，我们可以发现 虚表的地址和常量区/代码段的地址是最近的，因此虚表是存放在常量区/代码段的。

    2.多继承中的虚函数表

    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.  
    9. class Base2 {
    10. public:
    11. 	virtual void func1() { cout << "Base2::func1" << endl; }
    12. 	virtual void func2() { cout << "Base2::func2" << endl; }
    13. private:
    14. 	int b2;
    15. };
    16.  
    17. class Derive : public Base1, public Base2 {
    18. public:
    19. 	virtual void func1() { cout << "Derive::func1" << endl; }
    20. 	virtual void func3() { cout << "Derive::func3" << endl; }
    21. private:
    22. 	int d1;
    23. };
    24.  
    25. typedef void(*VFPTR) ();
    26. void PrintVTable(VFPTR vTable[])
    27. {
    28. 	// 依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数
    29. 	cout << " 虚表地址>" << vTable << endl;
    30. 	for (int i = 0; vTable[i] != nullptr; ++i)
    31. 	{
    32. 		printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
    33. 		VFPTR f = vTable[i];
    34. 		f();
    35. 	}
    36. 	cout << endl;
    37. }
    38.  
    39. int main()
    40. {
    41. 	printf("%p\n", &Derive::func1);
    42.  
    43. 	Derive d;
    44. 	//PrintVTable((VFPTR*)(*(int*)&d));
    45. 	PrintVTable((VFPTR*)(*(int*)&d));
    46. 	PrintVTable((VFPTR*)(*(int*)((char*)&d+sizeof(Base1))));
    47.  
    48. 	Base1* ptr1 = &d;
    49. 	Base2* ptr2 = &d;
    50. 	Derive* ptr3 = &d;
    51. 	cout << ptr1 << endl;
    52. 	cout << ptr2 << endl;
    53. 	cout << ptr3 << endl;
    54.  
    55. 	return 0;
    56. }

            多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中。

            看地址会发现这些地址都不同，很奇怪。如果我们看汇编，会发现中间有一个sub  ecx，这个是因为Derive对象Base2虚表中func1，是Base2指针ptr2去调用的，但是这时ptr2发生切片指针偏移，需要修正。中途就需要修正存储this指针ecx的值。因此vs对此进行了多次操作，导致地址出现不同。

            菱形继承和菱形虚拟继承非常复杂，并且实际中很少用，这里就不介绍了。

  • 相关阅读:
    C语言第六课：函数（1）——分类、参数与调用
    基于移动应用的城市公共气象服务平台的设计与实现
    Spring MVC中如何获取Request,Response对象方法呢？
    shell编程之命令替换
    java如何实现单例设计模式
    基于 Web 的 RADIUS 认证服务
    CD206抗体载Fe3O4的PLGA纳米微球/多烯紫杉醇-PLGA纳米粒的制备研究
    关于easyExcel导出文字合并居中和服务器导出失败踩了一天的坑
    win10系统的应用商店不见了怎么安装回来
    计算机保研er历程分享（浙软、厦大、华师、东南网安、东北、西电、中南......）
  • 原文地址：https://blog.csdn.net/qq_60750110/article/details/125902344