C++入门学习：多态案例--电脑组装

案例描述：
  电脑主要组成部件为CPU（用于计算），显卡（用于显示），内存条（用于存储）
  将每个零件封装出抽象类，并且提供不同的厂商提供不同的零件，例如Intel厂商和Lenovo厂商
  创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口
  测试时组装三台不同的电脑进行工作

先抽象不同的零件类  如CPU  包含一个工作函数

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

再创建电脑类  构造函数中获取所需的各种零件  并可以执行工作

Computer(CPU* cpu)
{
	m_cpu = cpu;
}

void work()
{
	//让零件工作起来  调用接口
	m_cpu->calculate();
}

同时提供不同的厂商的零件  如Intel的CPU  继承CPU的抽象类

class IntelCPU : public CPU
{
public:
	virtual void calculate()
	{
		cout << "Intel的CPU开始计算了" << endl;
	}
};

最后组装电脑

Computer* computer1 = new Computer(new IntelCPU);
cout << "第一台电脑开始工作" << endl;
computer1->work();
delete computer1;
cout << endl;

---

代码示例

#include 
#include 
using namespace std;

//抽象不同的零件类
//抽象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();
	}
	//提供析构函数  释放3个电脑零件
	~Computer()
	{
		//释放CPU
		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;//CPU的零件指针
	VideoCard* m_vc;//显卡的零件指针
	Memory* m_mem;//内存条的零件指针
};

//具体厂商
//Intel厂商
class IntelCPU : public CPU
{
public:
	virtual void calculate()
	{
		cout << "Intel的CPU开始计算了" << endl;
	}
};
class IntelVideoCard : public VideoCard
{
public:
	virtual void display()
	{
		cout << "Intel的显卡开始显示了" << endl;
	}
};
class IntelMemory : public Memory
{
public:
	virtual void storage()
	{
		cout << "Intel的内存条开始存储了" << endl;
	}
};

//lenovo产商
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 * intelcpu = new IntelCPU;
	VideoCard * intelvc = new IntelVideoCard;
	Memory * intelmem = new IntelMemory;

	//组装第一台电脑
	Computer* computer1 = new Computer(intelcpu, intelvc, intelmem);
	cout << "第一台电脑开始工作" << endl;
	computer1->work();
	delete computer1;
	cout << endl;

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

	//组装第三台电脑
	Computer* computer3 = new Computer(new LenovoCPU, new IntelVideoCard, new LenovoMemory);
	cout << "第三台电脑开始工作" << endl;
	computer3->work();
	delete computer3;
}


int main()
{
	test01();
	system("pause");
	return 0;
}

这个案例中 

函数调用只需要使用Computer中统一抽象类零件接口  而不是厂商零件中的具体实现 

新增厂商只需继承抽象零件类中的接口  而不需要修改Computer类中的代码

体现了多态通过抽象基类和虚函数机制  实现 高层模块不依赖低层细节  而是依赖抽象 的优点