抽象工厂模式
定义：
提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
适用性：
1、 一个系统需要独立于它的产品的创建，组合和表示时
2、 一个系统需要由多个产品系列中的一个配置时
3、 当需要强调一系列相关的产品对象的设计以便进行联合使用时
4、 当提供一个产品类库，而只想显示它们的接口而不是实现时
优点：
1、 分离了具体类，使得客户与类的实现分离
2、 抑郁交换产品系列。
3、 有利于产品的一致性
缺点：
难以支持新种类的产品，不容易扩展
结构类图：
实现：< http://www.2cto.com/kf/ware/vc/" target="_blank" class="keylink">vcD4KPHA+IDwvcD4KPHAgYWxpZ249"left">
//产品类A的接口
class AbstractProductA
{
public:
virtual void funA() = 0;
protected:
private:
};
//A产品分有1和两个等级的产品
class ConcreteProductA1:public AbstractProductA
{
public:
voidfunA()
{
cout<<"ConcreteProductA1 funA()"<
}
protected:
private:
};
class ConcreteProductA2:public AbstractProductA
{
public:
voidfunA()
{
cout<<"ConcreteProductA2 funA()"<
}
protected:
private:
};
//产品类B的接口
class AbstractProductB
{
public:
virtual void funB() = 0;
protected:
private:
};
//B产品分有1和两个等级的产品
class ConcreteProductB1:public AbstractProductB
{
public:
voidfunB()
{
cout<<"ConcreteProductB1 funB()"<
}
protected:
private:
};
class ConcreteProductB2:public AbstractProductB
{
public:
voidfunB()
{
cout<<"ConcreteProductB2 funB()"<
}
protected:
private:
};
//抽象工厂，可以创建A和两类产品
class AbstractFactory
{
public:
virtualAbstractProductA *CreateProductA() = 0;
virtualAbstractProductB *CreateProductB() = 0;
protected:
private:
};
//具体产品工厂类，创建等级1的产品
class ConcretFactory1:public AbstractFactory
{
public:
AbstractProductA *CreateProductA()
{
returnnew ConcreteProductA1;
}
AbstractProductB *CreateProductB()
{
return new ConcreteProductB1;
}
protected:
private:
};
//具体产品工厂类，创建等级2的产品
class ConcretFactory2:public AbstractFactory
{
public:
AbstractProductA *CreateProductA()
{
returnnew ConcreteProductA2;
}
AbstractProductB *CreateProductB()
{
returnnew ConcreteProductB2;
}
protected:
private:
};
AbstractFactory*pFactory1 = new ConcretFactory1;
AbstractFactory *pFactory2 = new ConcretFactory2;
AbstractProductA *pA1 =pFactory1->CreateProductA();
AbstractProductA *pA2 = pFactory2->CreateProductA();
pA1->funA();
pA2->funA();
AbstractProductB *pB1 =pFactory1->CreateProductB();
AbstractProductB *pB2 =pFactory2->CreateProductB();
pB1->funB();
pB2->funB();
