• 多态(个人学习笔记黑马学习)

    多态分为两类

    • 静态多态: 函数重载和 运算符重载属于静态多态，复用函数名
    • 动态多态: 派生类和虚图数实现运行时多态

    静态多态和动态多态区别:

    • 静态多态的函数地址早绑定 · 编译阶段确定函数地址
    • 动态多态的函数地址晚绑定 · 运行阶段确定函数地址

    1、基本语法

    1. #include 
    2. using namespace std;
    3. #include 
    4.  
    5. //动物类
    6. class Animal {
    7. public:
    8. 	//虚函数
    9. 	virtual void speak() {
    10. 		cout << "动物在说话" << endl;
    11. 	}
    12. };
    13.  
    14. //猫类 
    15. class Cat :public Animal {
    16. public:
    17.  
    18. 	//重写 函数返回值类型 函数名 参数列表 完全相同
    19. 	void speak() {
    20. 		cout << "小猫在说话" << endl;
    21. 	}
    22. };
    23.  
    24. //狗类
    25. class Dog :public Animal {
    26. public:
    27. 	void speak() {
    28. 		cout << "小狗在说话" << endl;
    29. 	}
    30. };
    31.  
    32. //执行说话的函数
    33. //地址早绑定 在编译阶段确定函数地址
    34. //如果想执行让猫说话，那么这个函数地址就不能提前绑定，需要在运行阶段进行绑定，地址晚绑定
    35.  
    36. //动态多态满足条件
    37. //1、有继承关系
    38. //2、子类重写父类的虚函数
    39.  
    40. //动态多态的使用
    41. //父类的指针或者引用 指向子类对象
    42.  
    43. void doSpeak(Animal& animal) {  //Animal& animal = cat;
    44. 	animal.speak();
    45. }
    46.  
    47. void test01() {
    48. 	Cat cat;
    49. 	doSpeak(cat);
    50.  
    51. 	Dog dog;
    52. 	doSpeak(dog);
    53. }
    54.  
    55. int main() {
    56.  
    57. 	test01();
    58.  
    59.  
    60. 	system("pause");
    61. 	return 0;
    62. }

    2、案例1：计算器类

    案例描述:
    分别利用普通写法和多态技术，设计实现两个操作数进行运算的计算器类

    1. #include 
    2. using namespace std;
    3. #include 
    4.  
    5. //普通写法
    6. class Calculator {
    7. public:
    8.  
    9. 	int getResult(string oper) {
    10. 		if (oper == "+") {
    11. 			return m_Num1 + m_Num2;
    12. 		}
    13. 		else if (oper == "-") {
    14. 			return m_Num1 - m_Num2;
    15. 		}
    16. 		else if (oper == "*") {
    17. 			return m_Num1 * m_Num2;
    18. 		}
    19. 		//如果想扩展新的功能，需要修改源码
    20. 		//在真正的开发中 提倡 开闭原则
    21. 		//开闭原则：对扩展进行开发，对修改进行关闭
    22. 	}
    23.  
    24. 	int m_Num1;//操作数1
    25. 	int m_Num2;//操作数2
    26. };
    27.  
    28. void test01() {
    29.  
    30. 	//创建计算器对象
    31. 	Calculator c;
    32. 	c.m_Num1 = 10;
    33. 	c.m_Num2 = 10; 
    34.  
    35. 	cout << c.m_Num1 << "+" << c.m_Num2 << "=" << c.getResult("+") << endl;
    36. 	cout << c.m_Num1 << "-" << c.m_Num2 << "=" << c.getResult("-") << endl;
    37. 	cout << c.m_Num1 << "*" << c.m_Num2 << "=" << c.getResult("*") << endl;
    38. }
    39.  
    40. //利用多态实现计算器
    41. //多态好处：
    42. // 1、组织结构清晰
    43. // 2、可读性强
    44. // 3、对前期和后期拓展和维护性高
    45. //实现计算器抽象类
    46. class AbstractCalculator {
    47. public:
    48. 	virtual int getResult() {
    49. 		return 0;
    50. 	}
    51.  
    52. 	int m_Num1;
    53. 	int m_Num2;
    54. };
    55.  
    56. //加法计算器类
    57. class AddCalculator :public AbstractCalculator {
    58. public:
    59. 	 int getResult() {
    60. 		 return m_Num1 + m_Num2;
    61. 	}
    62. };
    63.  
    64. //减法计算器类
    65. class SubCalculator :public AbstractCalculator {
    66. public:
    67. 	int getResult() {
    68. 		return m_Num1 - m_Num2;
    69. 	}
    70. };
    71.  
    72. //乘法计算器类
    73. class MulCalculator :public AbstractCalculator {
    74. public:
    75. 	int getResult() {
    76. 		return m_Num1 * m_Num2;
    77. 	}
    78. };
    79.  
    80. void test02() {
    81.  
    82. 	//多态使用
    83. 	//父类指针或者引用指向子类对象
    84. 	// 
    85. 	//加法运算
    86. 	AbstractCalculator* abc = new AddCalculator;
    87. 	abc->m_Num1 = 100;
    88. 	abc->m_Num2 = 100;
    89.  
    90. 	cout << abc->m_Num1 << "+" << abc->m_Num2 << "=" << abc->getResult() << endl;
    91. 	//用完后记得销毁
    92. 	delete abc;
    93. 	abc = NULL;		
    94.  
    95. 	//减法运算
    96. 	abc = new SubCalculator;
    97. 	abc->m_Num1 = 100;
    98. 	abc->m_Num2 = 100;
    99.  
    100. 	cout << abc->m_Num1 << "-" << abc->m_Num2 << "=" << abc->getResult() << endl;
    101. 	delete abc;
    102. 	abc = NULL;
    103.  
    104.  
    105. 	//乘法运算
    106. 	abc = new MulCalculator;
    107. 	abc->m_Num1 = 100;
    108. 	abc->m_Num2 = 100;
    109.  
    110. 	cout << abc->m_Num1 << "*" << abc->m_Num2 << "=" << abc->getResult() << endl;
    111. 	delete abc;
    112. 	abc = NULL;
    113.  
    114.  
    115. }
    116.  
    117. int main() {
    118.  
    119. 	//test01();
    120. 	test02();
    121.  
    122. 	system("pause");
    123. 	return 0;
    124. }

    3、纯虚函数和抽象类

    1. #include 
    2. using namespace std;
    3. #include 
    4.  
    5. class Base {
    6. public:
    7. 	//纯虚函数
    8. 	//只要有一个纯虚函数，这个类称为抽象类
    9. 	//抽象类特点：
    10. 	//1、无法实例化对象
    11. 	//2、抽象类的子类 必须要重写父类中的纯虚函数，否则也属于抽象类
    12. 	virtual void func() = 0;
    13. };
    14.  
    15. class Son :public Base {
    16. public:
    17. 	virtual void func() {
    18. 		cout << "fun()函数调用" << endl;
    19. 	}
    20. };
    21.  
    22. void test01() {
    23. 	//Base b;//抽象类无法实例化对象
    24. 	//new Base;//抽象类无法实例化对象
    25.  
    26. 	//Son s;//子类必须重写父类中的纯虚函数，否则无法实例化对象
    27. 	Base* base = new Son;
    28. 	base->func();
    29.  
    30. }
    31.  
    32. int main() {
    33.  
    34.  
    35.  
    36. 	system("pause");
    37. 	return 0;
    38. }

    4、案例2：制作饮品

    案例描述:
    制作饮品的大致流程为: 煮水 冲泡 倒入杯中 加入辅料
    利用多态技术实现本案例，提供抽象制作饮品基类，提供子类制作咖啡和茶叶

    1. #include 
    2. using namespace std;
    3. #include 
    4.  
    5. class AbstractDrinking {
    6. public:
    7.  
    8. 	//煮水
    9. 	virtual void Boil() = 0;
    10.  
    11. 	//冲泡
    12. 	virtual void Brew() = 0;
    13. 	//倒入杯中
    14. 	virtual void PourInCup() = 0;
    15. 	//加入辅料
    16. 	virtual void PutSomething() = 0;
    17.  
    18. 	//制作饮品
    19. 	void makeDrink() {
    20. 		Boil();
    21. 		Brew();
    22. 		PourInCup();
    23. 		PutSomething();
    24. 	}
    25.  
    26. };
    27.  
    28.  
    29. //制作咖啡
    30. class Coffee:public AbstractDrinking {
    31. public:
    32. 	//煮水
    33. 	virtual void Boil() {
    34. 		cout << "煮农夫山泉" << endl;
    35. 	};
    36.  
    37. 	//冲泡
    38. 	virtual void Brew() {
    39. 		cout << "冲泡咖啡" << endl;
    40. 	};
    41. 	//倒入杯中
    42. 	virtual void PourInCup() {
    43. 		cout << "倒入杯中" << endl;
    44. 	};
    45. 	//加入辅料
    46. 	virtual void PutSomething() {
    47. 		cout << "加入糖和牛奶" << endl;
    48. 	};
    49. };
    50.  
    51.  
    52. //制作茶叶
    53. class Tea :public AbstractDrinking {
    54. public:
    55. 	//煮水
    56. 	virtual void Boil() {
    57. 		cout << "煮矿泉水" << endl;
    58. 	};
    59.  
    60. 	//冲泡
    61. 	virtual void Brew() {
    62. 		cout << "冲泡茶叶" << endl;
    63. 	};
    64. 	//倒入杯中
    65. 	virtual void PourInCup() {
    66. 		cout << "倒入杯中" << endl;
    67. 	};
    68. 	//加入辅料
    69. 	virtual void PutSomething() {
    70. 		cout << "加入枸杞" << endl;
    71. 	};
    72. };
    73.  
    74.  
    75. //制作函数
    76. void doWork(AbstractDrinking* abs) {//AbstractDrinking* abs=new Coffee;
    77. 	abs->makeDrink();
    78. 	delete abs;//释放		
    79. }
    80.  
    81.  
    82. void test01() {
    83.  
    84. 	//制作咖啡
    85. 	doWork(new Coffee);
    86.  
    87. 	cout << "---------------" << endl;
    88. 	//制作茶叶
    89. 	doWork(new Tea);
    90. 	
    91.  
    92. }
    93.  
    94. int main() {
    95. 	test01();
    96.  
    97.  
    98. 	system("pause");
    99. 	return 0;
    100. }

    5、虚析构和纯虚析构 

    虚析构和纯虚析构共性

    • 可以解决父类指针释放子类对象
    • 都需要有具体的函数实现

    虚析构和纯虚析构区别:

    • 如果是纯虚析构，该类属于抽象类，无法实例化对象
    1. #include 
    2. using namespace std;
    3. #include 
    4.  
    5. class Animal {
    6. public:
    7. 	Animal() {
    8. 		cout << "Animal构造函数调用" << endl;
    9. 	}
    10.  
    11. 	//利用虚析构可以解决 父类指针释放子类对象时不干净的问题
    12. 	/*virtual ~Animal()
    13. 	{
    14. 		cout<< "Animal虚析构函数调用" << endl;
    15. 	}*/
    16. 	//纯虚析构 需要声明也需要实现
    17. 	virtual ~Animal() = 0;
    18.  
    19. 	//纯虚函数
    20. 	virtual void speak() = 0;
    21. };
    22. Animal:: ~Animal() {
    23. 	cout << "Animal纯虚析构函数调用" << endl;
    24. }
    25.  
    26. class Cat :public Animal {
    27. public:
    28.  
    29. 	Cat(string name) {
    30. 		cout << "Cat构造函数调用" << endl;
    31. 		m_Name= new string(name);
    32.  
    33. 	}
    34. 	virtual void speak() {
    35. 		cout << +m_Name<<"小猫在说话" << endl;
    36. 	}
    37. 	~Cat() {
    38. 		if (m_Name != NULL) {
    39. 			cout << "Cat析构函数调用" << endl;
    40. 			delete m_Name;
    41. 			m_Name = NULL; 
    42. 		}
    43. 	}
    44.  
    45. 	string* m_Name;
    46. };
    47.  
    48.  
    49. void test01() {
    50. 	Animal* animal = new Cat("Tom");
    51. 	animal->speak();
    52. 	//父类指针在析构时候 不会调用子类中析构函数，导致子类如果有堆区属性，出现内存泄露
    53. 	delete animal;  
    54. }
    55.  
    56. int main() {
    57.  
    58. 	test01();
    59.  
    60. 	system("pause");
    61. 	return 0;
    62. }

    6、案例三：电脑组装

    • 电脑主要组成部件为 CPU (用于计算)，显卡 (用于显示)，内存条 (用于存储)
    • 将每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件，例如Intel厂商和Lenovo厂商
    • 创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口
    • 测试时组装三台不同的电脑进行工作
    1. #include 
    2. using namespace std;
    3. #include 
    4.  
    5. //抽象不同零件类
    6.  
    7. //抽象CPU类
    8. class CPU {
    9. public:
    10. 	//抽象的计算函数
    11. 	virtual void calculate() = 0;
    12.  
    13. };
    14.  
    15. //抽象显卡类
    16. class VideoCard {
    17. public:
    18. 	//抽象的显示函数
    19. 	virtual void display() = 0;
    20.  
    21. };
    22.  
    23. //抽象内存条类
    24. class Memory {
    25. public:
    26. 	//抽象的存储函数
    27. 	virtual void storage() = 0;
    28.  
    29. };
    30.  
    31.  
    32. //电脑类
    33. class Computer {
    34. public:
    35. 	Computer(CPU* cpu, VideoCard* vc, Memory* mem) {
    36. 		m_cpu = cpu;
    37. 		m_vc = vc;
    38. 		m_mem = mem;
    39. 	}
    40.  
    41. 	//提供工作的函数
    42. 	void work() {
    43.  
    44. 		//让零件工作起来，调用接口
    45. 		m_cpu->calculate();
    46.  
    47. 		m_vc->display();
    48.  
    49. 		m_mem->storage();
    50. 	}
    51.  
    52. 	//提供析构函数 释放3个电脑零件
    53. 	~Computer() {
    54.  
    55. 		//释放cpu零件
    56. 		if (m_cpu != NULL) {
    57. 			delete m_cpu;
    58. 			m_cpu = NULL;
    59. 		}
    60.  
    61. 		//释放显卡零件
    62. 		if (m_vc != NULL) {
    63. 			delete m_vc;
    64. 			m_vc = NULL;
    65. 		}
    66.  
    67. 		//释放内存条零件
    68. 		if (m_mem != NULL) {
    69. 			delete m_mem;
    70. 			m_mem = NULL;
    71. 		}
    72. 	}
    73.  
    74. private:
    75. 	CPU* m_cpu;//CPU的零件指针
    76. 	VideoCard* m_vc;//显卡零件指针
    77. 	Memory* m_mem;//内存条零件指针
    78. };
    79.  
    80. //具体厂商
    81. //Intel厂商
    82. class IntelCPU :public CPU {
    83. public:
    84. 	virtual void calculate() {
    85. 		cout << "Intel的CPU开始计算了" << endl;
    86. 	}
    87. };
    88.  
    89. class IntelVideoCard :public VideoCard {
    90. public:
    91. 	virtual void display() {
    92. 		cout << "Intel的显卡开始显示了" << endl;
    93. 	}
    94. };
    95.  
    96. class IntelMemory :public Memory {
    97. public:
    98. 	virtual void storage() {
    99. 		cout << "Intel的内存条开始存储了" << endl;
    100. 	}
    101. };
    102.  
    103.  
    104. //Lenvo厂商
    105. class LenvoCPU :public CPU {
    106. public:
    107. 	virtual void calculate() {
    108. 		cout << "Lenvo的CPU开始计算了" << endl;
    109. 	}
    110. };
    111.  
    112. class LenvoVideoCard :public VideoCard {
    113. public:
    114. 	virtual void display() {
    115. 		cout << "Lenvo的显卡开始显示了" << endl;
    116. 	}
    117. };
    118.  
    119. class LenvoMemory :public Memory {
    120. public:
    121. 	virtual void storage() {
    122. 		cout << "Lenvo的内存条开始存储了" << endl;
    123. 	}
    124. };
    125.  
    126.  
    127. void test01() {
    128.  
    129. 	//第一台电脑零件
    130. 	CPU* intelCpu = new IntelCPU;
    131. 	VideoCard* intelCard = new IntelVideoCard;
    132. 	Memory* intelMem = new IntelMemory;
    133.  
    134. 	cout << "第一台电脑开始工作" << endl;
    135. 	//创建第一台电脑
    136. 	Computer* computer1 = new Computer(intelCpu, intelCard, intelMem);
    137. 	computer1->work();
    138. 	delete computer1;
    139.  
    140.  
    141. 	cout << "---------------------" << endl;
    142. 	cout << "第二台电脑开始工作" << endl;
    143. 	//创建第二台电脑
    144. 	Computer* computer2 = new Computer(new LenvoCPU,new LenvoVideoCard,new LenvoMemory);
    145. 	computer2->work();
    146. 	delete computer2;
    147.  
    148. 	cout << "---------------------" << endl;
    149. 	cout << "第三台电脑开始工作" << endl;
    150. 	//创建第三台电脑
    151. 	Computer* computer3 = new Computer(new LenvoCPU, new IntelVideoCard, new LenvoMemory);
    152. 	computer3->work();
    153. 	delete computer3;
    154. }
    155.  
    156.  
    157. int main() {
    158.  
    159. 	test01();
    160.  
    161. 	system("pause");
    162. 	return 0;
    163. }

  • 相关阅读:
    C#中错误与异常处理
    使用Spring Boot和MyBatis访问数据库
    华为配置wlan
    编写一个代码将一个带头节点的单链表A分解为两个带头结点的A和B，使得A表中含有原表中序号为奇数的元素，B表中含有序号为偶数的元素，保持相对位置不变
    自定义表单开源好用吗？有哪些优势特点？
    学生如何利用假期提升个人能力？
    PCL 点云超体素分割-SupervoxelClustering
    提升媒体文字质量：常见错误及改进措施解析
    postgresql数据库docker
    期货开户手续费加一分是主流
  • 原文地址：https://blog.csdn.net/m0_59848857/article/details/132697791