多态案例（电脑组装具体实现）

最新推荐文章于 2024-07-10 22:49:54 发布

小林想被监督学习

最新推荐文章于 2024-07-10 22:49:54 发布

阅读量204

点赞数

文章标签： c++

本文链接：https://blog.csdn.net/q322359/article/details/126930871

版权

用该案例主要体会多态的运用，多态的建立。

多态可以通过父类（基类）的指针或引用作用于子类的对象，根据传入子类的类型来判断使用哪个子类中的函数。

要使用多态，父类中要定义虚函数，子类中要重写虚函数。

父类中的函数不需要实现，可直接将其定义为纯虚函数，父类变为抽象类

电脑有3个主要的零件CPU,显卡，内存条

抽象这3个零件，及创建这3个零件的父类，子类由具体的公司实现

//抽象CPU类
	class CPU
	{
	public:
		//抽象计数函数（CPU的功能）
		virtual void Calculate() = 0;//纯虚函数

	};
	
	//抽象显卡类
	class VideoCard
	{
	public:
		//抽象显示函数（显卡的功能）
		virtual void Display() = 0;//纯虚函数
	};

	//抽象内存条类
	class Memory
	{
	public:
		//抽象储存函数（内存条的功能）
		virtual void Storage() = 0;//纯虚函数
	};
	//以上三个作为基类（父类），因为都定义的是纯虚函数所以都是抽象类和抽象函数

定义电脑类，电脑类的属性有以上的三个零件，功能有调用3个零件功能的作用

//电脑类
	class Computer
	{
	public:
		//电脑类的构造函数，初始化是哪个厂家的零件
		Computer(CPU* cpu, VideoCard* videocard, Memory* meory)
		{
			m_cpu = cpu;
			m_videocard = videocard;
			m_meory = meory;
		}
		//电脑进行工作的函数,调用接口
		//多态的体现，会根据传入的是哪个子类的指针来判断调用哪个子类中的函数
		void Work()
		{
			m_cpu->Calculate();
			m_videocard->Display();
			m_meory->Storage();
		}
		//在电脑类中释放具体零件指针指向的堆区空间
		~Computer()
		{
			delete(m_cpu);
			delete(m_videocard);
			delete(m_meory);
			cout << "堆区内存已释放" << endl;
		}
	private:
		CPU* m_cpu;//CPU的零件指针
		VideoCard* m_videocard;//显卡的零件指针
		Memory* m_meory;//内存条的零件指针
	};

接下来就定义上面3个零件抽象类的子类，将3个零件及其功能具体实现（零件分为两个厂商生产，便于更直观的表现多态）

//具体厂商
	//intel厂商
	//子类（派生类）IntelCPU以public的方式继承父类(基类)CPU
	class Intel_CPU :public CPU
	{
	public:
		virtual void Calculate()
		{
			cout << "Intel的CPU开始计算" << endl;
		}
	};

	class Intel_VideoCard :public VideoCard
	{
	public:
		virtual void Display()
		{
			cout << "Intel的VideoCard开始显示" << endl;
		}
	};

	class Intel_Memory :public Memory
	{
	public:
		virtual void Storage()
		{
			cout << "Intel的Memory开始储存" << endl;
		}
	};

//ASUS厂商
	class ASUS_CPU :public CPU
	{
	public:
		virtual void Calculate()
		{
			cout << "ASUS的CPU开始计算" << endl;
		}
	};

	class ASUS_VideoCard :public VideoCard
	{
	public:
		virtual void Display()
		{
			cout << "ASUS的VideoCard开始显示" << endl;
		}
	};

	class ASUS_Memory :public Memory
	{
	public:
		virtual void Storage()
		{
			cout << "ASUS的Memory开始储存" << endl;
		}
	};

子类创建完毕，接下来写执行函数，创建出零件和电脑的实体

//定义test01执行函数（第一台电脑的组装）
	void test01()
	{
		//具体创建特定厂商的零件
		//多态的使用：用父类的指针或引用作用于子类的对象
		//在堆区开辟了空间，要记得自己释放
		//运用多态会根据父类的指针指向的子类对象类型而判断使用哪个子类中的函数
		CPU* intel_CPU = new Intel_CPU;
		VideoCard* intel_VideoCard = new Intel_VideoCard;
		Memory* intel_Memory = new Intel_Memory;
		//定义一个电脑类的对象
		Computer*computer1=new Computer(intel_CPU, intel_VideoCard, intel_Memory);
		computer1->Work();
		//将堆区的内存释放
		delete computer1;
	}

这里要释放具体电脑零件在堆区所占空间的方法还有一个

delete intel_CPU;
delete intel_VideoCard;
delete intel_Memory;

但是这个方法肉眼可见的呆，由于我们的零件是电脑的属性，所以可以在电脑类中编写一个析构函数，将零件所创建在堆区中的空间释放掉，这样我们在程序最后delete computer1便可以将创建在堆区中的电脑和零件全部释放掉

第二台电脑的执行函数


	//定义test02执行函数（第二台电脑的组装）
	void test02()
	{
		//具体创建特定厂商的零件
		//多态的使用：用父类的指针或引用作用于子类的对象
		//在堆区开辟了空间，要记得自己释放
		//运用多态会根据父类的指针指向的子类对象类型而判断使用哪个子类中的函数
		Computer* computer2 = new Computer(new ASUS_CPU, new ASUS_VideoCard,new ASUS_Memory);
		computer2->Work();
		delete computer2;
	}

第二台电脑的创建比第一台电脑肉眼可见的简便，我们可以直接在Computer初始化的时候将具体的零件直接创建进去，就不用父类的指针来指向子类具体的零件后，再传入父类指针到构造函数中这种迂回的方法。

代码展示：

#include<iostream>
using namespace std;
	//抽象CPU类
	class CPU
	{
	public:
		//抽象计数函数（CPU的功能）
		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* videocard, Memory* meory)
		{
			m_cpu = cpu;
			m_videocard = videocard;
			m_meory = meory;
		}
		//电脑进行工作的函数,调用接口
		//多态的体现，会根据传入的是哪个子类的指针来判断调用哪个子类中的函数
		void Work()
		{
			m_cpu->Calculate();
			m_videocard->Display();
			m_meory->Storage();
		}
		//在电脑类中释放具体零件指针指向的堆区空间
		~Computer()
		{
			delete(m_cpu);
			delete(m_videocard);
			delete(m_meory);
			cout << "堆区内存已释放" << endl;
		}
	private:
		CPU* m_cpu;//CPU的零件指针
		VideoCard* m_videocard;//显卡的零件指针
		Memory* m_meory;//内存条的零件指针
	};

	//具体厂商
	//intel厂商
	//子类（派生类）IntelCPU以public的方式继承父类(基类)CPU
	class Intel_CPU :public CPU
	{
	public:
		virtual void Calculate()
		{
			cout << "Intel的CPU开始计算" << endl;
		}
	};

	class Intel_VideoCard :public VideoCard
	{
	public:
		virtual void Display()
		{
			cout << "Intel的VideoCard开始显示" << endl;
		}
	};

	class Intel_Memory :public Memory
	{
	public:
		virtual void Storage()
		{
			cout << "Intel的Memory开始储存" << endl;
		}
	};

	//ASUS厂商
	class ASUS_CPU :public CPU
	{
	public:
		virtual void Calculate()
		{
			cout << "ASUS的CPU开始计算" << endl;
		}
	};

	class ASUS_VideoCard :public VideoCard
	{
	public:
		virtual void Display()
		{
			cout << "ASUS的VideoCard开始显示" << endl;
		}
	};

	class ASUS_Memory :public Memory
	{
	public:
		virtual void Storage()
		{
			cout << "ASUS的Memory开始储存" << endl;
		}
	};

	//定义test01执行函数（第一台电脑的组装）
	void test01()
	{
		//具体创建特定厂商的零件
		//多态的使用：用父类的指针或引用作用于子类的对象
		//在堆区开辟了空间，要记得自己释放
		//运用多态会根据父类的指针指向的子类对象类型而判断使用哪个子类中的函数
		CPU* intel_CPU = new Intel_CPU;
		VideoCard* intel_VideoCard = new Intel_VideoCard;
		Memory* intel_Memory = new Intel_Memory;
		//定义一个电脑类的对象
		Computer*computer1=new Computer(intel_CPU, intel_VideoCard, intel_Memory);
		computer1->Work();
		//将堆区的内存释放
		delete computer1;
	}

	//定义test02执行函数（第二台电脑的组装）
	void test02()
	{
		//具体创建特定厂商的零件
		//多态的使用：用父类的指针或引用作用于子类的对象
		//在堆区开辟了空间，要记得自己释放
		//运用多态会根据父类的指针指向的子类对象类型而判断使用哪个子类中的函数
		Computer* computer2 = new Computer(new ASUS_CPU, new ASUS_VideoCard,new ASUS_Memory);
		computer2->Work();
		delete computer2;
	}
	int main()
	{
		test01();
		cout << endl;
		test02();
		system("pause");
		return 0;
	}

多态的运用案例完成。