黑马：多态（135~142）

最新推荐文章于 2024-08-12 16:55:46 发布
最新推荐文章于 2024-08-12 16:55:46 发布
阅读量157 收藏 2
点赞数
分类专栏： 黑马C++笔记 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_55746492/article/details/120639286
版权
本文深入探讨了C++中的多态性，包括静态多态和动态多态的区别，通过动物、计算器、饮品制作等案例展示了多态的应用。强调了动态多态在运行时函数地址绑定的特点，并指出虚函数和纯虚函数在实现多态中的作用。同时，讨论了虚析构函数和纯虚析构函数的用途，以及如何利用它们解决父类指针释放子类对象的问题。文章还通过电脑组装案例展示了多态在系统设计中的灵活性。
摘要由CSDN通过智能技术生成

1.多态的基本概念

多态分为两类：


静态多态：函数重载 和 运算符重载属于静态多态，复用函数名

动态多态：派生类和虚函数实现运行时多态

静态多态和动态多态的区别：

静态多态的函数地址早绑定——编译阶段确定函数地址

动态多态的函数地址晚绑定——运行阶段确定函数地址

#include<iostream>
using namespace std;
#include<string>
#include<vector>
#include<deque>
#include<iterator>
#include<list>
#include<algorithm>
#include<numeric>
#include<map>
#include<set>
#include<utility>

//多态

//动物类
class Animal {
public: 
	virtual void speak() {   //变成虚函数实现晚绑定
		cout << "动物在说话" << endl;
	}
};

//猫类
class Cat :public Animal {
	void speak() {
		cout << "小猫在说话" << endl;
	}
};

//狗类
class Dog :public Animal {
	void speak() {
		cout << "小狗在说话" << endl;
	}
};

//动态多态满足条件
// 1.有继承关系
// 2.子类要重写(函数返回值和参数列表完全相同）父类的虚函数（都是speak）

//动态多态使用
// 父类的指针或引用执行子类对象（Animal &animal）


//执行说话的函数
//地址早绑定 在编译阶段确定函数地址
//如果要让猫说话 就要让函数地址不能提前绑定，需要在运行阶段绑定，即晚绑定
void doSpeak(Animal &animal) {
	animal.speak();
}

void test01() {
	Cat cat;
	doSpeak(cat);

	Dog dog;
	doSpeak(dog);
}



int main(int argc,char**argv) {
		
	test01();

	system("pause");
	return  0;
}

2.动态的原理剖析

3.多态案例一 计算器类

多态的优点：

代码组织结构清晰

可读性强

利于前期和后期的扩展以及维护

#include<iostream>
using namespace std;
#include<string>
#include<vector>
#include<deque>
#include<iterator>
#include<list>
#include<algorithm>
#include<numeric>
#include<map>
#include<set>
#include<utility>

//分别利用普通写法和多态写计算器

//普通写法

class Calculator {
public:

	int getResult(string oper) {
		if (oper == "+") {
			return m_Num1 +  m_Num2;
		}
		else if (oper == "-") {
			return m_Num1 - m_Num2;
		}
		else if (oper == "*"){
			return m_Num1 * m_Num2;
		}
		//如果想拓展新功能（除法），需要修改源码
	}
	int m_Num1;
	int m_Num2;
};

void test01() {
	Calculator c;
	c.m_Num1 = 10;
	c.m_Num2 = 10;
	cout << c.m_Num1 << "+" << c.m_Num2 <<"="<< c.getResult("+") << endl;
}



//利用多态实现计算器

//实现计算器抽象类
class AbstractCalculator {
public:
	virtual int getResult() {
		return 0;
	}

	int m_Num1;
	int m_Num2;
};

//加法计算器类
class AddCalculator :public AbstractCalculator{
public:
	int getResult() {
		return m_Num1 + m_Num2;
	}
};

//减法计算器类
class SubCalculator :public AbstractCalculator {
public:
	int getResult() {
		return m_Num1 - m_Num2;
	}
};

//乘法计算器类
class MulCalculator :public AbstractCalculator {
public:
	int getResult() {
		return m_Num1 * m_Num2;
	}
};

void test02() {
	//多态使用条件：父类的引用或指针指向子类对象

	//加法运算
	AbstractCalculator* abc = new AddCalculator;
	abc->m_Num1 = 10;
	abc->m_Num2 = 10;
	cout << abc->m_Num1 << "+" << abc->m_Num2 << "=" << abc->getResult() << endl;
	//用完后记得销毁（new，开辟在堆区，手动创造手动释放）
	delete abc;

	//减法运算
	abc = new SubCalculator;
	abc->m_Num1 = 100;
	abc->m_Num2 = 100;
	cout << abc->m_Num1 << "-" << abc->m_Num2 << "=" << abc->getResult() << endl;
	delete abc;

	//乘法运算
	abc = new MulCalculator;
	abc->m_Num1 = 100;
	abc->m_Num2 = 100;
	cout << abc->m_Num1 << "*" << abc->m_Num2 << "=" << abc->getResult() << endl;
	delete abc;
}

//多态的好处
//1.组织结构清晰
//2.可读性强
//3.对于前期和后期的拓展以及维护性高
int main(int argc,char**argv) {
		
	//test01();
	test02();

	system("pause");
	return  0;
}

4.纯虚函数和抽象类

多态中，通常父类中虚函数的实现毫无意义，主要都是调用子类的内容

因此可以将虚函数改为纯虚函数

语法：virtual 返回值类型 函数名 （参数列表） =0；

当类中有了纯虚函数，这个类也成为抽象类

抽象类特点

无法实例化对象

子类必须重写抽象类中的纯虚函数，否则也属于抽象类

#include<iostream>
using namespace std;
#include<string>
#include<vector>
#include<deque>
#include<iterator>
#include<list>
#include<algorithm>
#include<numeric>
#include<map>
#include<set>
#include<utility>

//纯虚函数和抽象类
class Base {
public:
	//纯虚函数
	//只要有一个纯虚函数 这个类就是抽象类
	
	virtual void func() = 0;
};

class Son :public Base {
public:
	void func() {
		cout << "func函数调用" << endl;
	}
};

void test01() {
	//抽象类不允许实例化对象
	// Base b;   报错 栈区不行
	// new Base; 报错 堆区也不行

	//Son s 如果25到27行什么也不写（即没有重写父类中的纯虚函数，也将无法实例化对象，这行会报错）

	Base* base = new Son; 
	base->func();

}

int main(int argc,char**argv) {
		
	test01();
	

	system("pause");
	return  0;
}

5.多态案例二  制作饮品

#include<iostream>
using namespace std;
#include<string>
#include<vector>
#include<deque>
#include<iterator>
#include<list>
#include<algorithm>
#include<numeric>
#include<map>
#include<set>
#include<utility>

class AbstractDrinking {
public:
	//煮水
	virtual void Boil() = 0;

	//冲泡
	virtual void Brew() = 0;

	//倒入杯中
	virtual void PourInCup() = 0;

	//加入辅料
	virtual void PutSomething() = 0;

	//制作饮品
	void makeDrink() {
		Boil();
		Brew();
		PourInCup();
		PutSomething();

	}
};

 //制作咖啡
class Coffee :public AbstractDrinking {
public:
	//煮水
	virtual void Boil() {
		cout << "煮农夫山泉" << endl;
	}

	//冲泡
	virtual void Brew() {
		cout << "冲泡咖啡" << endl;
	}

	//倒入杯中
	virtual void PourInCup() {
		cout << "倒入杯中" << endl;
	}

	//加入辅料
	virtual void PutSomething() {
		cout << "加入牛奶和咖啡" << endl;
	}

};

//制作茶叶
class Tea :public AbstractDrinking {
public:
	//煮水
	virtual void Boil() {
		cout << "煮矿泉水" << endl;
	}

	//冲泡
	virtual void Brew() {
		cout << "冲泡茶叶" << endl;
	}

	//倒入杯中
	virtual void PourInCup() {
		cout << "倒入杯中" << endl;
	}

	//加入辅料
	virtual void PutSomething() {
		cout << "加入枸杞" << endl;
	}

};

//制作函数
void doWork(AbstractDrinking * abs) {
	abs->makeDrink(); //多态 同一个接口 传入不同的饮品
	delete abs;
}

void test01() {
	//制作咖啡
	doWork(new Coffee);

	cout << "-----------------------------" << endl;

	//制作茶叶
	doWork(new Tea);
}
int main(int argc,char**argv) {
		
	test01();
	

	system("pause");
	return  0;
}

6.虚析构和纯虚析构

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

解决方式：将父类中的析构函数改为虚析构或者纯虚析构

虚析构和纯虚析构共性：

1.可以解决父类指针释放子类对象

2..都需要有具体的函数实现

虚析构和纯虚析构区别：

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

虚析构语法：

virtual ~类名(){}

纯虚析构语法：

virtual ~类名（）=0；

类名：：~类名（）{}

#include<iostream>
using namespace std;
#include<string>
#include<vector>
#include<deque>
#include<iterator>
#include<list>
#include<algorithm>
#include<numeric>
#include<map>
#include<set>
#include<utility>

//虚析构和纯虚析构
class Animal {
public:

	Animal() {
		cout << "Animal构造函数调用" << endl;
	}

	//利用虚析构可以解决 父类指针释放子类对象时不干净的问题
	/*virtual ~Animal() {  
		cout << "Animal虚析构函数调用" << endl;
	}*/

	//我把上面的虚析构函数体注释了，因为虚析构和纯虚析构只能有一个

	//纯虚析构
	virtual ~Animal() = 0;   //因为没有类似24行所调用的函数体，只靠这一行的声明是不够的，还需要36行的实现

	//纯虚函数
	virtual void speak() = 0;
};

Animal::~Animal() {
	cout << "Animal纯虚析构函数调用" << endl;
}

class Cat :public Animal {
public:
	Cat(string name) {
		cout << "cat构造函数调用" << endl;
		m_Name = new string(name); 
	}

	 virtual void speak() {
		cout <<*m_Name<< "小猫在说话" << endl;
	}

	 ~Cat() {
		 if (m_Name != NULL) {
			 cout << "cat析构函数调用" << endl;
			 delete m_Name;
			 m_Name = NULL;
		 }
	 }

	 string *m_Name;
};

void test01() {
	Animal* animal = new Cat("Tom");
	animal->speak();
	//父类指针在析构时候 不会调用子类中析构函数，导致子类中如果有堆区属性，会出现内存泄漏；
	delete animal;
	
}
int main(int argc,char**argv) {
		
	test01();
	

	system("pause");
	return  0;
}

总结：

1.虚析构或纯虚析构就是用来解决父类指针释放子类对象

2.如果子类中没有堆区数据，可以不写虚析构或纯虚析构

3.拥有纯虚析构的类也属于抽象类

7.多态案例三 电脑组装

#include<iostream>
using namespace std;
#include<string>
#include<vector>
#include<deque>
#include<iterator>
#include<list>
#include<algorithm>
#include<numeric>
#include<map>
#include<set>
#include<utility>

//抽象不同零件类
//抽象CPU类
class CPU {
public:
	//抽象的计算函数
	virtual void calculate() = 0;
};

//抽象显卡类
class VideoCard	 {
public:
	//抽象的显示函数
	virtual void display() = 0;
};

//抽象内存条类
class Memory {
public:
	//抽象的存储函数
	virtual void storage() = 0;
};


//电脑类
class Computer {
public:
	Computer(CPU* cpu, VideoCard* vc, Memory* mem) {
		m_cpu = cpu;
		m_vc = vc;
		m_mem = mem;
	}

	//提供工作的函数
	void work() {

		//让零件工作起来 调用接口
		m_cpu->calculate();
		m_vc->display();
		m_mem->storage();
	}

	~Computer() {
		if (m_cpu != NULL) {
			delete m_cpu;
			m_cpu = NULL;
		}

		if (m_vc != NULL) {
			delete m_vc;
			m_vc = NULL;
		}

		if (m_mem != NULL) {
			delete m_mem;
			m_mem = NULL;
		}
	}
private:
	CPU* m_cpu;
	VideoCard* m_vc;
	Memory* m_mem;

};


//具体厂商
//Intel厂商
class InterCPU :public CPU{
public:
	virtual void calculate() {
		cout << "Inter的CPU开始计算了！" << endl;
	}
};

class InterVideoCard :public VideoCard{
public:
	virtual void display() {
		cout << "Inter的显卡开始显示了！" << endl;
	}
};


class InterMemory :public Memory{
public:
	virtual void storage() {
		cout << "Inter的内存条开始存储了！" << endl;
	}
};



//Lenovo厂商
//Intel厂商
class LenovoCPU :public CPU{
public:
	virtual void calculate() {
		cout << "Lenovo的CPU开始计算了！" << endl;
	}
};

class LenovoVideoCard :public VideoCard{
public:
	virtual void display() {
		cout << "Lenovo的显卡开始显示了！" << endl;
	}
};


class LenovoMemory :public Memory{
public:
	virtual void storage() {
		cout << "Lenovo的内存条开始存储了！" << endl;
	}
};


void test01() {
		//第一台电脑
		CPU* intercpu = new InterCPU;
		VideoCard* intercard = new InterVideoCard;
		Memory* intelmem = new InterMemory;

		//创建第一台电脑
		cout << "第一台电脑开始工作" << endl;
		Computer* computer1 = new Computer(intercpu, intercard, intelmem);
		computer1->work();
		delete computer1;

		cout << "-----------------" << endl;

		//创建第二台电脑
		cout << "第二台电脑开始工作" << endl;	
		Computer* computer2 = new Computer(new LenovoCPU, new LenovoVideoCard, new LenovoMemory);
		computer2->work();
		delete computer2;
		

	}

int main(int argc,char**argv) {
		
	test01();
	

	system("pause");
	return  0;
}

至臻卡比兽
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
黑马JAVA P114 多态综合案例
weixin_51015079的博客
01-10 418
package com.itheima.d4_polymorphic_test; /** * USB接口 == 规范 */ public interface USB { // 接入 拔出 void connect(); void unconnect(); } package com.itheima.d4_polymorphic_test; /** * 实现类 */ public class Mouse implements USB{ privat...
C++ 类和对象:多态案例
qq_44797904的博客
06-27 113
多态案例 – 计算器类 -------- 根据黑马程序员视频所做笔记 案例描述： 分别利用普通写法和多态技术，设计实现两个操作数进行运算的计算器类 多态的优点： 代码组织结构清晰 可读性强 利于前期和斗气的扩展以及维护 示例： #include<iostream> #include<string> using namespace std; //分别利用普通写法和多态技术实现计算器 //普通写法 class Calculator { public: int getResult(
黑马程序员——多态
u012865586的专栏
12-21 396
------- android培训、java培训、期待与您交流！ ----------    多态：某一类事物的多种存在形态 多态的体现：父类的引用指向自己的子类对象 对象多态的前提：   1：类与类(或接口)要有继承(或实现)关系。   2：一定要有方法的覆盖。 多态的好处   多态的出现大大的提高了程序的扩展性。  多态的弊端   提高了扩展性，但是只能使用父类的引
黑马程序员-多态
Shaylow的专栏
12-24 244
---------------------- android培训、java培训、期待与您交流！ ---------------------- 多态 1）多态 2）Object类 3）内部类 4）包 1多态 定义：多态可理解为事物存在的多种体现形态 体现： 1）父类引用指向子类对象 2）父类引用接收子类对象 3）接口引用指向自己的子类对象 好处：提高了程序的扩展性
黑马程序员 多态
li13615680696的专栏
04-22 393
概念： 一个事物的多种形态 多态前提和体现 有继承关系或者实现关系 有方法重写 有父类引用指向子类对象 成员访问特点 方法的运行看右边，其他都看左边 多态的好处 提高了程序的维护性(由继承保证) 提高了程序的扩展性(由多态保证) 多态的弊端: 父类不能访问子类的特有方法 如果非要访问，向下转型(强转) 向上转型 从子到父 父类引用指向子
黑马程序——多态（黑马我来了之七）
zhc117711077的专栏
04-20 241
---------------------- android培训、java培训、期待与您交流！ ---------------------- 面向对象 多态、内部类、异常、包 1、多态：可以理解为事物存在的多种体现形态。 人：男人，女人 动物：猫，狗。 猫 x = new 猫(); 动物 x = new 猫(); 1，多态的体现 父类的引用指向了自己的子类对象。 父类的引
Java面向对象：多态
月光晒了很凉快的博客
08-04 101
多态的相关知识。
C++黑马程序员学习资料
08-05
C++黑马程序员学习资料，附赠《InterviewGuide第四版By阿秀》、《LeetCode刷题手册》、《背包问题九讲》、《算法图解》pdf版本，三个基础课程文档手册及三个实验项目，由简到繁分别为《通讯录管理系统》、《职工管理...
黑马程序员匠心之作 C++教程_第4阶段实战-基于多态的企业职工系统讲义.rar
03-19
《C++教程_第4阶段实战-基于多态的企业职工系统讲义》是黑马程序员精心制作的一份教学资源，特别适合C++初学者。这份讲义深入浅出地讲解了C++编程语言中的多态性，并通过实战项目——企业职工系统，让学习者能够将...
基于多态的职工管理系统.zip
10-03
此代码根据黑马程序员课程案例学习编写，如果想知道具体教程，欢迎大家去https://www.bilibili.com/video/BV1et411b73Z?p=2&spm_id_from=pageDriver 观看教材学习。 管理系统中需要实现的功能如下： 退出管理程序：...
基于多态的职工管理系统.rar
09-07
本教程主要利用C++来实现一个基于多态的职工管理系统 公司中职工分为三类：普通员工、经理、老板，显示信息时，需要显示职工编号、职工姓名、职工岗位、以及职责 普通员工职责：完成经理交给的任务 经理职责：...
基于C++ STL实现的多态机房预约系统
05-02
基于C++ STL实现一个多态的机房管理系统 分别有三种身份使用该程序：学生、教师、管理员；机房总共有3间。 1.申请的订单每周由管理员负责清空。 2.学生可以预约未来一周内的机房使用，预约的日期为周一至周五，预约...
C++笔记5•内存管理•
最新发布
qq_64446190的博客
08-12 662
内存管理
STL中的迭代器失效（vector为例）
2302_80190394的博客
08-08 357
STL中的迭代器失效（vector为例）
c++ error: ‘*’ does not name a type； did you mean ‘**’?
xiaozhi
08-08 474
c++ error: ‘*’ does not name a type； did you mean ‘**’?
C语言一维数组(含数组二分查找)
hdxbufcbjuhg的博客
08-09 1187
在⼀个升序的数组中查找指定的数字n，很容易想到的⽅法就是遍历数组，但是这种⽅法效率⽐较低。比如我们之前写的猜数字游戏，会生成一个随机数来让玩家猜，范围是1~100，那玩家会从1开始一个一个猜吗，不会吧，那样就太慢了，我们一般会从整体的一半开始猜，比如猜50，告诉你大了还是小了，这样只需要一步就可以排除庞大数字中的一半，比如假设猜1 ~ 10000，猜5000后就可以知道猜大了还是小了，直接排除了5000个数字，效率很快，这就是⼆分查找，也叫折半查找。
【C++】智能指针
dab112的博客
08-07 908
谈论了内存泄漏，以及可以使用智能指针来解决该类问题
浙大版《C语言程序设计（第3版）》题目集
qq_67330059的博客
08-08 146
其中m和n是用户传入的参数，保证有m<n。函数返回的是m~n之间所有整数的和。
黑马C++基于多态的
10-06
基于多态的C++黑马编程是指通过使用基类的指针或引用来调用派生类的成员函数，从而实现运行时的多态性。在黑马C中，可以通过继承和虚函数来实现多态。继承是指一个类从另一个类派生出来，被派生的类称为子类或派生类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值