设计模式之二 ------AbstractFactory

         设计模式之一 ------AbstractFactory

问题：有很多基类，这些基类派生出各自的类，并且基类派生出来的类的个数相等，我们要用多个工厂管理每个基类的中各个子类（说起来有点拗口，可以用一张图来表示）

解决方案：

把这些共同点抽象出来，就是把创建对象的方法抽象出来，这就是抽象工厂

场景描述：

我们程序猿经常玩游戏，例如魔兽RPG，进入游戏后让你选择游戏难度，简单、中等、困难。在这游戏设计中就需要考虑这个问题：游戏中，有不同类型的怪物，怪物有这三种难度级别，在不同级别下，我们需要创建不同难度的怪物；

解决方案：

#include<iostream>

using namespace std;

class ProductA{//产品基类

public:

ProductA(){}

virtual ~ProductA(){}

};

class ConcreateProductA1:public ProductA{//产品实现类类，被Factory创建

public:

ConcreateProductA1(){cout<<"create ConcreateProductA1;"<<endl;}

virtual ~ConcreateProductA1(){}

};

class ConcreateProductA2:public ProductA{//产品实现类类，被Factory创建

public:

ConcreateProductA2(){cout<<"create ConcreateProductA2;"<<endl;}

virtual ~ConcreateProductA2(){}

};

class ProductB{//产品基类

public:

ProductB(){}

virtual ~ProductB(){}

};

class ConcreateProductB1:public ProductB{//产品实现类类，被Factory创建

public:

ConcreateProductB1(){cout<<"create ConcreateProductB1;"<<endl;}

virtual ~ConcreateProductB1(){}

};

class ConcreateProductB2:public ProductB{//产品实现类类，被Factory创建

public:

ConcreateProductB2(){cout<<"create ConcreateProductB2;"<<endl;}

virtual ~ConcreateProductB2(){}

};

class AbstractFactory{//工厂类的基类，让子类实现具体创建哪个产品

public:

AbstractFactory(){}

virtual ProductA *CreateProductA()=0;

virtual ProductB *CreateProductB()=0;

virtual ~AbstractFactory(){}

};

class ConcreateFactory1:public AbstractFactory

{

public:

ConcreateFactory1(){cout<<"ConcreateFacory1 被创建;"<<endl;}

virtual ProductA * CreateProductA()

{

return new ConcreateProductA1;

}

virtual ProductB * CreateProductB()

{

return new ConcreateProductB1;

}

virtual ~ConcreateFactory1(){}

};

class ConcreateFactory2:public AbstractFactory

{

public:

ConcreateFactory2(){cout<<"ConcreateFacory2 被创建;"<<endl;}

virtual ProductA * CreateProductA()

{

return new ConcreateProductA2;

}

virtual ProductB * CreateProductB()

{

return new ConcreateProductB2;

}

virtual ~ConcreateFactory2(){}

};

void main()

{

AbstractFactory *abs1=new ConcreateFactory1;

AbstractFactory *abs2=new ConcreateFactory2;

ProductA * a=abs1->CreateProductA();

ProductB * b=abs1->CreateProductB();

delete a;//上一篇，忘记把内存释放了

delete b;

a=abs2->CreateProductA();

b=abs2->CreateProductB();

delete a;

delete b;

}