抽象工厂模式--AbstactFactory

http://blog.csdn.net/qq575787460/article/details/8087289简要的说了下简单工厂模式。接着继续说抽象工厂模式。

假设现在不是要产生怪物A，怪物B。而是要要产生简单的怪物A，困难的怪物A，简单的怪物B，困难的怪物B。这是不能简单的把怪物作为基类，而是要把怪物A，怪物B作为两个基类，然后分别派生出简单的怪物A，困难的怪物A以及简单的怪物B，困难的怪物B。这是应采用抽象工厂模式。

抽象工厂模式解决的问题：一组相关或相互依赖的类。

#include <iostream>
#include <memory>
using namespace std;
//怪物A基类
class monsterA
{
public:
	virtual void show()=0;
	virtual ~monsterA(){}
};
//简单难度的怪物A
class easyMonsterA:public monsterA
{
public:
	void show()
	{
		cout<<"简单难度的怪物A"<<endl;
	}
};
//困难难度的怪物A
class hardMonsterA:public monsterA
{
public:
	void show()
	{
		cout<<"困难难度的怪物A"<<endl;
	}
};
//怪物B基类
class monsterB
{
public:
	virtual void show()=0;
	virtual ~monsterB(){}
};
//简单难度的怪物B
class easyMonsterB:public monsterB
{
public:
	void show()
	{
		cout<<"简单难度的怪物B"<<endl;
	}
};
//困难难度的怪物B
class hardMonsterB:public monsterB
{
public:
	void show()
	{
		cout<<"困难难度的怪物B"<<endl;
	}
};
//生产怪物的基类工厂
class factory
{
public:	
	virtual monsterA* createMonsterA()=0;
	virtual monsterB* createMonsterB()=0;
	virtual ~factory(){}
};
//生产简单怪物的工厂
class easyFactory:public factory
{
public:
	monsterA* createMonsterA()
	{
		return new easyMonsterA();
	}
	monsterB* createMonsterB()
	{
		return new easyMonsterB();
	}
};
//生产困难怪物的工厂
class hardFactory:public factory
{
public:
	monsterA* createMonsterA()
	{
		return new hardMonsterA();
	}
	monsterB* createMonsterB()
	{
		return new hardMonsterB();
	}
};
int main()
{
	factory *fEasy=new easyFactory();
	monsterA *easyA=fEasy->createMonsterA();
	easyA->show();
	delete easyA;
	monsterB *easyB=fEasy->createMonsterB();
	easyB->show();
	delete easyB;
	delete fEasy;

	factory *fHard=new hardFactory();
	monsterA* hardA=fHard->createMonsterA();
	hardA->show();
	delete hardA;
	monsterB *hardB=fHard->createMonsterB();
	hardB->show();
	delete hardB;
	delete fHard;
}