多态案例-电脑组装

//电脑中有零件：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();		//电脑类中的CPU类指针调用接口
		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;
};

//各种厂商提供的零件子类
class IntelCPU :public CPU {
public:
	void calculate() {
		cout << "Intel CPU Work！" << endl;
	}
};

class IntelVideoCard :public VideoCard {
public:
	void display() {
		cout << "Intel VideoCard  Work！" << endl;
	}
};

class IntelMemory :public Memory {
public:
	void storage() {
		cout << "Intel Memory Work！" << endl;
	}
};

class LenovoCPU :public CPU {
public:
	void calculate() {
		cout << "Lenovo CPU Work！" << endl;
	}
};

class LenovoVideoCard :public VideoCard {
public:
	void display() {
		cout << "Lenovo VideoCard  Work！" << endl;
	}
};

class LenovoMemory :public Memory {
public:
	void storage() {
		cout << "Lenovo Memory Work！" << endl;
	}
};

void test01(){
	CPU* intelCPU = new IntelCPU;
	VideoCard* intelCard = new IntelVideoCard;
	Memory* intelMem = new IntelMemory;
	Computer* computer1 = new Computer(intelCPU, intelCard, intelMem);
	computer1->Work();
	delete computer1;
}

int main() {
	test01();
}