• 浅谈C++|多态篇

    1.多态的基本概念

    多态是C++面向对象三大特性之一多态分为两类
    1. 静态多态:函数重载和运算符重载属于静态多态，复用函数名·

    2.动态多态:派生类和虚函数实现运行时多态
    静态多态和动态多态区别:
    ·静态多态的函数地址早绑定–编译阶段确定函数地址

    ·动态多态的函数地址晚绑定–运行阶段确定函数地址下面通过案例进行讲解多态

    动态多态满足条件

    1、有继承关系
    2、子类重写父类的虚函数

    动态多态使用
    父类的指针或者引用执行子类对象

    重写:函数返回值类型函数名参数列表完全—致称为重写

     静态多态代码：

    1. #include 
    2. using namespace std;
    3. class dongwu {
    4. public:
    5. 	void speak() {
    6. 		cout << "动物叫" << endl;
    7. 	}
    8. };
    9.  
    10. class cat :public dongwu {
    11. 	void speak() {
    12. 		cout << "猫叫" << endl;
    13. 	}
    14. };
    15. //早绑定，编译阶段就确定函数的地址
    16.  
    17. void speak(dongwu& p) {
    18. 	p.speak();
    19. }
    20. void fun() {
    21. 	cat p;
    22. 	speak(p);
    23. }
    24. int main() {
    25. 	fun();
    26. 	cat p;
    27. 	//发生隐式转换,只能把儿子转为父亲，退化
    28. 	dongwu m = p;
    29. 	m.speak();
    30. 	return 0;
    31. }

    注意转化，以及早绑定的特性是执行当前的类型的函数，不执行儿子的函数

    动态动态代码： 

    1. #include 
    2. using namespace std;
    3. class dongwu {
    4. public:
    5. 	//virtual虚函数关键字
    6. 	virtual void speak() {
    7. 		cout << "动物叫" << endl;
    8. 	}
    9. };
    10.  
    11. class cat :public dongwu {
    12. 	//子类的virtual可加可不加
    13. 	virtual void speak() {
    14. 		cout << "猫叫" << endl;
    15. 	}
    16. };
    17.  
    18. //晚绑定，执行子类的函数
    19. void speak(dongwu& p) {
    20. 	p.speak();
    21. }
    22. void fun() {
    23. 	cat p;
    24. 	speak(p);
    25. }
    26. int main() {
    27. 	fun();
    28. 	
    29. 	return 0;
    30. }

    二.多态的底层原理

    我们先看以下代码：

    1. #include 
    2. using namespace std;
    3. class father1 {
    4. public:
    5. 	void speak() {
    6. 		cout << "动物叫" << endl;
    7. 	}
    8. };
    9. class father2 {
    10. public:
    11. 	virtual void speak() {
    12. 		cout << "动物叫" << endl;
    13. 	}
    14. };
    15. int main() {
    16. 	cout << sizeof(father1) << endl;
    17. 	cout << sizeof(father2) << endl;
    18.  
    19. 	return 0;
    20. }

     当类的成员函数加入虚函数关键字后，会发现类的大小发生了改变。此时类的内部结构。此时类的内部会多一个指针虚函数（表）指针，虚函数指针指向虚函数表，虚函数表中存储虚函数的入口地址。

    那么当派生类继承基类后，如果成员函数没有重名，那么会完全继承父类的结构。 

     

     但是当派生类，重写基函数的虚函数时，派生类中的虚函数表会发生改变，此时虚函数表指向派生类的虚函数，基类的虚函数被覆盖。

     

     此时，我们有派生类隐式转换为基类时，虚函数表中的内容并不改变，此时调用虚函数，执行的是派生类的虚函数。

    三.多态的优点 

    1、组织结构清晰

    2、可读性强

    3、对于前期和后期扩展以及维护性高

     普通计算机类:

    1. #include 
    2. using namespace std;
    3. class jisuanqi {
    4. public:
    5. 	int a, b;
    6. 	int jisuan(string fu) {
    7. 		if (fu == "+") {
    8. 			return a + b;
    9. 		}
    10. 		else if (fu == "-") {
    11. 			return a - b;
    12. 		}
    13. 		else if (fu == "*") {
    14. 			return a * b;
    15. 		}
    16. 	}
    17. };
    18. void fun() {
    19. 	jisuanqi q;
    20. 	q.a = 200;
    21. 	q.b = 100;
    22. 	cout << q.a << " - " << q.b << " = " << q.jisuan("-") << endl;
    23. 	cout << q.a << " + " << q.b << " = " << q.jisuan("+") << endl;
    24. 	cout << q.a << " * " << q.b << " = " << q.jisuan("*") << endl;
    25.  
    26. }
    27. int main() {
    28. 	fun();
    29. 	return 0;
    30. }

     多态计算机类：

    1. #include 
    2. using namespace std;
    3. class jisuanqi {
    4. public:
    5. 	int a;
    6. 	int b;
    7. 	virtual int jisuan() {
    8. 		return 0;
    9. 	}
    10. };
    11.  
    12. class add :public jisuanqi {
    13. 	virtual int jisuan() {
    14. 		return a+b;
    15. 	}
    16. };
    17.  
    18. class jian :public jisuanqi {
    19. 	virtual int jisuan() {
    20. 		return a - b;
    21. 	}
    22. };
    23.  
    24. class cheng:public jisuanqi {
    25. 	virtual int jisuan() {
    26. 		return a * b;
    27. 	}
    28. };
    29.  
    30. void fun() {
    31. 	jisuanqi* p = new add;
    32. 	p->a = 200;
    33. 	p->b = 100;
    34. 	cout << p->a << " + " << p->b << " = " << p->jisuan()<
    35. 	delete p;
    36. 	
    37. 	p = new jian;
    38. 	p->a = 200;
    39. 	p->b = 100;
    40. 	cout << p->a << " - " << p->b << " = " << p->jisuan()<
    41. 	delete p;
    42.  
    43.  
    44. 	p = new cheng;
    45. 	p->a = 200;
    46. 	p->b = 100;
    47. 	cout << p->a << " * " << p->b << " = " << p->jisuan()<
    48. 	delete p;
    49. }
    50. int main() {
    51. 	fun();
    52. 	return 0;
    53. }

    四.纯虚函数和抽象类

    在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容因此可以将虚函数改为纯虚函数。当类中有了纯虚函数，这个类也称为抽象类

    纯虚函数语法: virtual    返回值类型   函数名︰（参数列表）= 0 ;

    抽象类特点:
        ·无法实例化对象
        ·子类必须重写抽象类中的纯虚函数，否则也属于抽象类
     

     代码：

    1. #include 
    2. using namespace std;
    3.  
    4. class father {
    5. public:
    6. 	//纯虚函数
    7. 	virtual void fun() = 0;
    8. };
    9.  
    10.  
    11. class son :public father{
    12. public:
    13. 	void fun() {
    14. 		cout << "我是sond" << endl;
    15. 	}
    16. };
    17.  
    18. void fun() {
    19. 	//多态f必须是指针或者引用
    20. 	//father f; 报错不可实例化
    21. 	father* f = new son;
    22. 	f->fun();
    23. }
    24. int main() {
    25. 	fun();
    26. 	return 0;
    27. }

    案例制作饮品：

    1. #include 
    2. using namespace std;
    3. class father {
    4. public:
    5. 	virtual void zhushui() = 0;
    6. 	virtual void chongpao() = 0;
    7. 	virtual void daoru() = 0;
    8. 	virtual void jialiao() = 0;
    9. 	void fun() {
    10. 		zhushui();
    11. 		chongpao();
    12. 		daoru();
    13. 		jialiao();
    14. 	}
    15. };
    16.  
    17. class tea :public father{
    18. 	void zhushui() {
    19. 		cout << "煮山泉水" << endl;
    20. 	};
    21. 	void chongpao() {
    22. 		cout << "冲茶" << endl;
    23. 	};
    24. 	void daoru() {
    25. 		cout << "倒入茶杯中" << endl;
    26. 	};
    27. 	void jialiao() {
    28. 		cout << "加入枸杞" << endl;
    29. 	};
    30. };
    31.  
    32. class kafei : public father{
    33. 	void zhushui() {
    34. 		cout << "煮水" << endl;
    35. 	};
    36. 	void chongpao() {
    37. 		cout << "冲咖啡" << endl;
    38. 	};
    39. 	void daoru() {
    40. 		cout << "倒入咖啡杯中" << endl;
    41. 	};
    42. 	void jialiao() {
    43. 		cout << "加入奶和糖" << endl;
    44. 	};
    45. };
    46. //函数接口
    47. void fun(father* p) {
    48. 	p->fun();
    49. 	delete p;
    50. }
    51. int main() {
    52. 	fun(new tea);
    53. 	cout << "----------" << endl;
    54. 	fun(new kafei);
    55. 	return 0;
    56. }

    五. 虚析构和纯虚析构

    多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码
    解决方式:

    将父类中的析构函数改为虚析构或者纯虚析构


    虚析构和纯虚析构共性:
    ·可以解决父类指针释放子类对象·都需要有具体的函数实现


    虚析构和纯虚析构区别:
    ·如果是纯虚析构，该类属于抽象类，无法实例化对象

    代码： 

    1. #include 
    2. using namespace std;
    3. class father {
    4. public:
    5. 	//纯虚函数
    6. 	virtual void fun() =0;
    7. 	father() {
    8. 		cout << "father构造函数" << endl;
    9. 	}
    10. 	~father() {
    11. 		cout << "father析构函数" << endl;
    12. 	}
    13. };
    14.  
    15. class son :public father {
    16. public:
    17. 	//堆区开辟数据
    18. 	son(int age) {
    19. 		cout << "son构造函数" << endl;
    20. 		this->age = new int(age);
    21. 	}
    22.  
    23. 	~son() {
    24. 		cout << "son析构函数" << endl;
    25. 		if (this->age != NULL) {
    26. 			delete age;
    27. 			age = NULL;
    28. 		}
    29. 	}
    30. 	void fun() {
    31. 		cout << *age<< "son的fun函数调用" << endl;
    32. 	}
    33. 	int* age;
    34. };
    35. void fun() {
    36. 	
    37. 	father* p = new son(21);
    38. 	delete p;
    39. }
    40. int main() {
    41. 	fun();
    42. 	return 0;
    43. }

    如图，当发生多态时，基类并不会调用子类的析构函数，当子类中含有堆区开辟的空间时。会造成内存泄漏。此时需要虚析构或纯虚析构来解决。

    虚析构代码： 

    1. #include 
    2. using namespace std;
    3. class father {
    4. public:
    5. 	//纯虚函数
    6. 	virtual void fun() =0;
    7. 	father() {
    8. 		cout << "father构造函数" << endl;
    9. 	}
    10. 	virtual ~father() {
    11. 		cout << "father析构函数" << endl;
    12. 	}
    13. };
    14.  
    15. class son :public father {
    16. public:
    17. 	//堆区开辟数据
    18. 	son(int age) {
    19. 		cout << "son构造函数" << endl;
    20. 		this->age = new int(age);
    21. 	}
    22.  
    23. 	~son() {
    24. 		cout << "son析构函数" << endl;
    25. 		if (this->age != NULL) {
    26. 			delete age;
    27. 			age = NULL;
    28. 		}
    29. 	}
    30. 	void fun() {
    31. 		cout << *age<< "son的fun函数调用" << endl;
    32. 	}
    33. 	int* age;
    34. };
    35. void fun() {
    36. 	
    37. 	father* p = new son(21);
    38. 	delete p;
    39. }
    40. int main() {
    41. 	fun();
    42. 	return 0;
    43. }

    纯虚析构：

    1. #include 
    2. using namespace std;
    3. class father {
    4. public:
    5. 	//纯虚函数
    6. 	virtual void fun() =0;
    7. 	father() {
    8. 		cout << "father构造函数" << endl;
    9. 	}
    10. 	virtual ~father() = 0;
    11. };
    12. //纯虚函数必须
    13. father::~father()
    14. {
    15. 	cout << "father析构函数" << endl;
    16. }
    17.  
    18. class son :public father {
    19. public:
    20. 	//堆区开辟数据
    21. 	son(int age) {
    22. 		cout << "son构造函数" << endl;
    23. 		this->age = new int(age);
    24. 	}
    25.  
    26. 	~son() {
    27. 		cout << "son析构函数" << endl;
    28. 		if (this->age != NULL) {
    29. 			delete age;
    30. 			age = NULL;
    31. 		}
    32. 	}
    33. 	void fun() {
    34. 		cout << *age<< "son的fun函数调用" << endl;
    35. 	}
    36. 	int* age;
    37. };
    38. void fun() {
    39. 	
    40. 	father* p = new son(21);
    41. 	delete p;
    42. }
    43. int main() {
    44. 	fun();
    45. 	return 0;
    46. }

    案例计算机

    1. #include 
    2. using namespace std;
    3.  
    4. class CPU {
    5. public:
    6. 	//纯虚函数
    7. 	virtual void func() = 0;
    8. };
    9.  
    10. class  Memory_Module {
    11. public:
    12. 	//纯虚函数
    13. 	virtual void func() = 0;
    14. };
    15.  
    16. class  Graphics_card {
    17. public:
    18. 	//纯虚函数
    19. 	virtual void func() = 0;
    20. };
    21.  
    22.  
    23. class CPU_intel : public CPU {
    24. public:
    25. 	void func() {
    26. 		cout << "intel的CPU工作" << endl;
    27. 	}
    28. };
    29.  
    30. class Graphics_card_intel : public Graphics_card {
    31. public:
    32. 	void func() {
    33. 		cout << "intel的显卡工作" << endl;
    34. 	}
    35. };
    36.  
    37.  
    38.  
    39. class Memory_Module_intel : public Memory_Module {
    40. public:
    41. 	void func() {
    42. 		cout << "intel的内存条工作" << endl;
    43. 	}
    44. };
    45.  
    46.  
    47.  
    48. class CPU_lenovo: public CPU {
    49. public:
    50. 	void func() {
    51. 		cout << "联想的CPU工作" << endl;
    52. 	}
    53. };
    54.  
    55. class Graphics_card_lenovo : public Graphics_card {
    56. public:
    57. 	void func() {
    58. 		cout << "联想的显卡工作" << endl;
    59. 	}
    60. };
    61. class Memory_Module_lenovo : public Memory_Module {
    62. public:
    63. 	void func() {
    64. 		cout << "联想的内存条工作" << endl;
    65. 	}
    66. };
    67. class computer {
    68. public:
    69. 	//当传入的是子类时发生多态
    70. 	computer() {};
    71. 	computer(CPU* CPU , Memory_Module* m, Graphics_card* g) {
    72. 		this->cpu = CPU;
    73. 		this->m = m;
    74. 		this->g = g;
    75. 	}
    76. 	void work() {
    77. 		cpu->func();
    78. 		m->func();
    79. 		g->func();
    80. 	}
    81. private:
    82. 	CPU* cpu;
    83. 	Memory_Module* m;
    84. 	Graphics_card* g;
    85. };
    86.  
    87. void fun() {
    88. 	CPU_lenovo* c1 = new CPU_lenovo;
    89. 	CPU_intel* c2 = new CPU_intel;
    90. 	Graphics_card_intel* g1 = new Graphics_card_intel;
    91. 	Graphics_card_lenovo* g2 = new Graphics_card_lenovo;
    92. 	Memory_Module_intel* m1 = new Memory_Module_intel;
    93. 	Memory_Module_lenovo* m2 = new Memory_Module_lenovo;
    94.  
    95. 	cout << "第一台电脑" << endl;
    96. 	computer* com = new computer(c1,m1,g1);
    97. 	com->work();
    98. 	cout << "********************************" << endl;
    99. 	cout << "第二台电脑" << endl;
    100. 	computer* com1 = new computer(c2, m2, g2);
    101. 	
    102. 	com1->work();
    103. }
    104. int main() {
    105. 	fun();
    106. 	return 0;
    107. }

  • 相关阅读:
    ftp多用户多目录配置
    windows环境下mongodb 5.0.9分片集群环境搭建
    pgbouncer 使用
    猿创征文 第二季｜ #「笔耕不辍」--生命不息，写作不止#
    【第29例】IPD体系进阶：PL-TMT 产品线技术管理团队
    手把手怎么把照片修复高清，p图小白也能轻松上手
    leetcode42. 接雨水
    安装使用RocketMQ一套保姆全教程-最快完成SpringBoot使用消息队列demo
    判断是否工作在docker环境
    猿创征文｜基于STM32设计的物联网熏艾空气消毒装置(STM32+华为云IOT)
  • 原文地址：https://blog.csdn.net/m0_73731708/article/details/132927521