• 【C++】多态

    1.多态  

    1.1多态的概念：

    多态：就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。李明要吃饭，那就要吃早饭，午饭，晚饭，而不是一天只吃午饭这种单一情况。

    多态分为：静态多态，动态多态。

    我们原来写的重载的交换函数，参数类型有int,double fioat等等。这就构成了静态多态。这里的静态是指编译时。

    1.2多态构成条件 （动态多态）

    • 1. 必须通过基类的指针或者引用调用虚函数（被virtual修饰的函数）
    • 2. 被调用的函数必须是虚函数（virtual），且派生类必须对基类的虚函数进行重写（函数名、返回值、参数均相同 + 虚函数）这个virtual和继承里的那个用法不同，简称一词多义。

     接下来我们把图中的代码写一下

    1. class Food  //基类
    2. {
    3. public:
    4. 	virtual void eatfood()   // 虚函数
    5. 	{
    6. 		cout << "eat food--基类" << endl;
    7. 	}
    8. };
    9.  
    10. class Breakfast :public Food
    11. {
    12. public:
    13. 	virtual void eatfood()
    14. 	//void eatfood()  子类不需要加virtual也可以和父类的构成重写，但是不规范且有许多漏洞。
    15. 	{
    16. 		cout << "eat breakfast---派生" << endl;
    17. 	}
    18. };
    19.  
    20. class Lunch :public Food
    21. {
    22. public:
    23. 	virtual void eatfood()
    24. 	{
    25. 		cout << "eat Lunch----派生" << endl;
    26. 	}
    27. };
    28. void func1(Food e)   //吃饭
    29. {
    30. 	e.eatfood();
    31. }
    32. void func2(Food* e)   //吃饭
    33. {
    34. 	e->eatfood();
    35. }
    36. void func3(Food& e)   //吃饭
    37. {
    38. 	e.eatfood();
    39. }
    40. int main()
    41. {
    42. 	Food f;
    43.     Breakfast bf;
    44. 	Lunch l;
    45. 	func1(f);
    46. 	func1(bf);
    47. 	func1(l);
    48. 	//父类指针
    49. 	Food *pf=&f;
    50. 	Breakfast *pbf=&bf;
    51. 	Lunch *pl=&l;
    52. 	func2(pf);
    53. 	func2(pbf);
    54. 	func2(pl);
    55. 	//父类引用
    56. 	func3(f);
    57. 	func3(bf);
    58. 	func3(l);
    59. }
    • 1，func函数中用父类对象。会破坏多态条件，不构成多态。

    •  2.派生了的虚函数的virtual去掉也可以构成多态。但是这个写法极其不规范，也有很大漏洞。
    • 3.基类的虚函数去掉virtual就不构成多态了，切记！

    1.3虚函数重写的两大例外

    • 1.协变：

    派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。通俗的说是虚函数返回值类型为父子关系指针和引用。

    1. class Food  //基类
    2. {
    3. public:
    4. 	virtual Food* eatfood()   // 虚函数
    5. 	{
    6. 		cout << "eat food--基类" << endl;
    7. 		return new Food;
    8. 	}
    9. };
    10. class Breakfast :public Food
    11. {
    12. public:
    13. 	virtual Breakfast* eatfood()
    14. 		
    15. 	{
    16. 		cout << "eat breakfast---派生" << endl;
    17. 		return new Breakfast;
    18. 	}
    19. };
    20.  
    21. int main()
    22. {
    23. 	Food f;
    24. 	Food* pf = &f;
    25. 	f.eatfood();
    26. 	Breakfast bf;
    27. 	Breakfast* pbf=&bf;
    28. 	pbf->eatfood();
    29. }

     因为有协变的存在，所以虚函数重写后的返回值不一定相同 。

    • 2.析构函数的重写(子类与父类析构函数的名字不同)

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

    1. class Food  //基类
    2. {
    3. public:
    4. 	virtual ~Food()   // 虚函数
    5. 	{
    6. 		cout << "~Food()" << endl;
    7. 	}
    8. };
    9. class Breakfast :public Food
    10. {
    11. public:
    12. 	 ~Breakfast()
    13. 	{
    14. 		cout << "~Breakfast()---派生" << endl;
    15. 	}
    16. };
    17.  
    18. int main()
    19. {
    20. 	Food f;
    21. 	Breakfast bf;
    22. }


     

    • 如果我们把父类的virtual去掉

    • 结果没发生啥变化，但是我创建一个基类指针，指向派生类我们再看一下。 

    •  为啥全部都是指向父类了？如果我们在恢复virtual看一下

     把virtual在加上，就又恢复了。

    为了方便解释，我们在改一下

    •  delete需要做两步：1.调用析构

                                         2.函数释放空间

    • pf和pbf的空间都会被释放，pf指向父类对象，期望调用父类的析构函数，pbf指向子类对象，期望调用子类的析构函数，指向父类调父类，指向子类调子类，期望这里达到多态行为，虽然没有明显的函数调用，但是delete操作调了析构函数。
    • pbf指向子类对象，但是发现没有调用子类析构函数，可能存在内存泄漏：

    补充：继承中说的隐藏：

    1. 子类和父类的析构函数构成隐藏。原因就是表面上子类的析构函数个父类的析构函数名不同，但是为了构成重写，编译器会对析构函数名调用时，统一将父类和子类的析构函数名改成destructor( )。统一改成destructor( )构成隐藏的目的就是在这里能够调用同一个函数，达到多态指向父类对象就调父类对象，指向子类对象就调子类对象的的目的。
    2. 因此，父类函数中的virtual不能省，否则子类继承不了父类的virtual属性，无法重写父类的虚函数，如果这个函数是析构函数，那么还会造成内存泄漏。为了保持统一，父类和子类虚函数前面的virtual都不要省。

    2.C++11 override 和 final

    • final：如果修饰虚函数表示不想被重写；如果修饰类，表示不想被继承；都是在这个类，虚函数后面加final。

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

    3.重写，重载，隐藏

    •  虚函数重写也叫做覆盖，在子类中重写了一个和父类中的虚函数完全相同的虚函数：包括函数名、返回值、参数列表都相同，这时候子类就重写了父类的虚函数。
    • 子类重写的虚函数的函数名、返回值、参数列表和父类一定要完全相同，否则就变成了函数重载

    重载和重写的区别：

    1. 定义不同---重载是定义相同的方法名，参数不同;重写是子类重写父类的方法。
    2. 范围不同---重载是在一个类中，重写是子类与父类之间的。
    3. 多态不同---重载是编译时的多态性，重写是运行时的多态性。
    4. 返回不同---重载对返回类型没有要求，而重写要求返回类型必须相同。
    5. 参数不同---重载的参数个数、参数类型、参数顺序可以不同，而重写父子方法参数必须相同。
    6. 修饰不同---重载对访问修饰没有特殊要求，重写访问修饰符的限制一定要大于被重写方法的访问修饰符。

    4.抽象类

    4.1.纯虚函数

    格式：在虚函数后面写=0。

    抽象类：

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

     

     我们在派生类中再写一个虚函数，派生类就能实例化出对象了。

     4.2接口继承和实现继承：

    实现继承

    普通函数的继承是实现继承，不是接口继承，继承的是函数的实现，可以直接使用这个函数，也是一种复用。

    接口继承 

    虚函数包括纯虚函数的继承是接口继承，子类仅仅只继承了父类接口 ，父类没有实现这个接口函数，子类要对纯虚函数进行重写达到多态的目的。

    5.多态的原理

    5.1虚函数表 

    我们计算一下sizeof(a）

    1. class Father 
    2. {
    3. public:
    4. 	virtual void func()
    5. 	{
    6.  
    7. 	}
    8. 	int car;
    9. };
    10.  
    11. int main()
    12. {
    13. 	Father a;
    14. 	cout << "sizeof(a): " << sizeof(a) << endl;
    15. 	
    16. }

    就一个变量 car，所以是4。 

    但是我们看看结果。 


    没有调查就没有发言权！我们查一下内存再说话。

     我们就创建一个变量car，但是上面还有一个变量（很明显是个指针）。

    对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。

    为了方便观察，我们改进一下代码

    1. class Father
    2. {
    3. public:
    4. 	virtual void func1()
    5. 	{
    6. 		cout << "func1" << endl;
    7. 	}
    8. 	virtual void func2()
    9. 	{
    10. 		cout << "func2" << endl;
    11. 	}
    12. 	 void func3()
    13. 	{
    14. 		cout << "func3" << endl;
    15. 	}
    16. 	int car=1;
    17. };
    18. class Son :public Father
    19. {
    20. public:
    21. 	virtual void func2()   //让func2和father构成
    22. 	{}
    23. 	int phone = 2;
    24. };
    25.  
    26. int main()
    27. {
    28. 	Father a;
    29. 	cout << "sizeof(a): " << sizeof(a) << endl;
    30. 	Son  s;
    31. }

     看一下监视窗口。

    通过观察发现：

    1. 子类对象son中也有一个虚表指针，son对象由两部分构成，一部分是父类继承下来的成员，另一部分是自己的成员。
    2. 父类对象和子类对象虚表是不一样的，func2完成了重写，所以b的虚表中存的是重写的Son::func2，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。
    3. fun1继承下来后是虚函数，所以放进了虚表，func3也继承下来了，但是不是虚函数，所以不会放进虚表。
    4. 虚函数表本质是一个存虚函数指针的指针数组，这个数组最后面放了一个nullptr。
    5. 总结一下派生类的虚表生成：

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

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

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

    • 虚函数存在哪的？虚表存在哪的？

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

    多态是如何实现当父类指针指向父类对象时，调用父类的虚函数，而父类指针指向子类对象时，调用的就是子类的虚函数呢？ 接下来我们看看多态的原理。

    5.2多态的原理 

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. using namespace std;
    4.  
    5. class Food  //基类
    6. {
    7. public:
    8. 	virtual void eatfood()   // 虚函数
    9. 	{
    10. 		cout << "eat food--基类" << endl;
    11. 	}
    12. };
    13.  
    14. class Breakfast :public Food
    15. {
    16. public:
    17. 	virtual void eatfood()
    18. 		//void eatfood()  子类不需要加virtual也可以和父类的构成重写，但是不规范且有许多漏洞。
    19. 	{
    20. 		cout << "eat breakfast---派生" << endl;
    21. 	}
    22. };
    23.  
    24. void func(Food& e)   //吃饭
    25. {
    26. 	e.eatfood();
    27. }
    28. int main()
    29. {
    30. 	Food f;
    31. 	func(f);
    32. 	Breakfast bf;
    33. 	func(bf);
    34. }

     我们看，父类的对象f被e指向时，调用func函数的eatfood并且在虚数表中找到虚函数Food::eatfood.

    子类的对象bf也是这样，但是eatfood会在虚数表中找到虚函数Breakfast::eatfood。

     如果子类没有重写父类的虚函数，此时就破坏了多态的形成条件，那此时和上面的情况会一样吗？

    此时就不再是上面的情况了。

    父类调用： 

    我们不在用父类指针和父类引用了，我们用一下父类调用。

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. using namespace std;
    4.  
    5. class Food  //基类
    6. {
    7. public:
    8. 	virtual void eatfood()   // 虚函数
    9. 	{
    10. 		cout << "eat food--基类" << endl;
    11. 	}
    12. };
    13.  
    14. class Breakfast :public Food
    15. {
    16. public:
    17. 	virtual void eatfood()   // 虚函数
    18. 	{
    19. 		cout << "eat food--子类" << endl;
    20. 	}
    21. 	 
    22. };
    23.  
    24. void func(Food e)   //吃饭
    25. {
    26. 	e.eatfood();
    27. }
    28. int main()
    29. {
    30. 	Food a;
    31. 	func(a);
    32. 	Breakfast b;
    33. 	func(b);
    34. }
    • 此时就不在构成多态了。我们用子类对象入参时，那么指针和引用会把父类那部分切出来，切出来后不是赋值，而是让指针指向子类里面父类的那部分，这个指针无论指向的是父类还是子类，看到的都是父类对象，给父类引用的就是父类对象，给子类引用的是切片出来的父类对象。
    • 而构成多态时，引用和指针本身并不知道自己指向或引用的是父类对象还是子类对象，指向父类对象，那就指向或引用整个父类对象，指向子类对象，那就那看到的就是子类对象中父类那一部分。 

    5.3动态绑定和静态绑定

    • 静态绑定：又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载.
    • 动态绑定：又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。

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

    6.1单继承中的虚函数表

    虚函数表初始化分为3步：

    1. 开始执行基类的构造函数
    2. 初始化基类的成员
    3. 将基类构造函数执行完毕

    发现执行完以上3步之后，虚表指针已经初始化了： 

    虚表指针是在构造函数初始化列表阶段初始化的，虚表在编译时就已经生成了。

    一个类中所有的虚函数地址，都会放到虚表中。虚表里面存放的是虚函数地址，虚函数和普通函数一样， 编译完成后，都放在代码段。

    我们看一下派生类虚表生出过程

    我们用上面，funct1，func2, func3那个代码，我就不写这上面了。

    父类的虚表中存的是Aniaml的func1( )和func2( )的地址。生成子类虚表时，会单独开辟一块空间，拷贝一份父类虚表过程中，会将对应虚函数位置覆盖成子类重写了父类的虚函数，如果子类没有重写，那么父类的虚函数就不会被覆盖，保留。所以子类虚表的生成过程是一个拷贝+覆盖的过程。

    监视如上代码:

    （1）子类重写了父类的func2( )虚函数，所以子类会覆盖父类func2( )位置；

    （2）子类没有重写父类的func1( )虚函数，子类不会覆盖父类func1( )位置；

    （3）父类的Jump( )不是虚函数， 不会出现在虚表中：

     再看一下他们的地址变化。

    6.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. class Base2 {
    9. public:
    10. 	virtual void func1() { cout << "Base2::func1" << endl; }
    11. 	virtual void func2() { cout << "Base2::func2" << endl; }
    12. private:
    13. 	int b2;
    14. };
    15. class Derive : public Base1, public Base2 {
    16. public:
    17. 	virtual void func1() { cout << "Derive::func1" << endl; }
    18. 	virtual void func3() { cout << "Derive::func3" << endl; }
    19. private:
    20. 	int d1;
    21. };
    22. int main()
    23. {
    24. 	Derive d;
    25. 	return 0;
    26. }

     

     这跟单继承的虚表如出一辙。

    我们打印一下虚表：

    1. ypedef void(*VFPTR) ();
    2. void PrintVTable(VFPTR vTable[])
    3. {
    4. 	cout << " 虚表地址>" << vTable << endl;
    5. 	for (int i = 0; vTable[i] != nullptr; ++i)
    6. 	{
    7. 		printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
    8. 		VFPTR f = vTable[i];
    9. 		f();
    10. 	}
    11. 	cout << endl;
    12. }
    13. int main()
    14. {
    15. 	Derive d;
    16. 	PrintVTable((VFPTR*)(*(int*)&d));
    17. 	PrintVTable((VFPTR*)(*(int*)((char*)&d + sizeof(Base1))));
    18. 	return 0;
    19. }

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

    • 1.假设D类先继承B1，然后继承B2，B1和B2基类均包含虚函数，D类对B1和B2基类的虚函数重写了，并且D类增加了新的虚函数，则D类有几个虚表？D类的虚函数放在那个虚表后面？答案 2，第一个

    继承几个父类就有几个虚数表。d自己的虚函数放在第一个虚数表后面其他父类的虚表不需要存储，因为存储了也不能调用。

    • 2.父类和子类各自用各自的虚表。
    • 3.虚表实在编译期间生成的。
    • 4.编译时多态是早期绑定，主要通过重载实现；运行时多态注主要通过模板和虚函数实现。

  • 相关阅读:
    Spring cloud gateway+apollo=bug？
    【计算机图形学基础】阴影映射
    【Java 进阶篇】深入了解 Bootstrap 插件
    DDD 洋葱架构才是 yyds！阿里大牛手记（DDD）领域驱动设计应对之道
    2022 年最新 Java 后端薪资统计出炉，看看你有没有拖后腿
    Android 单一音量控制
    python数据分析及可视化（十四）数据分析可视化练习-上市公司可视化数据分析、黑色星期五案例分析
    代码随想录算法训练营第五十七天| 392.判断子序列、115.不同的子序列
    Linux常用命令
    游戏开发25可 cocoscreate2.x升级3.x
  • 原文地址：https://blog.csdn.net/bit_jie/article/details/127529162