设计模式的C++实现 3.抽象工厂

简单工厂模式和工厂模式 要求 同一类型的产品子类拥有共同的方法，这限制了产品子类的扩展。抽象工厂可以向客户端提供一个接口，是客户端在不必指定产品的具体情况下，创建多个产品族中的产品对象。抽象工厂中将同一类的产品子类归为一类，让它们继承同一个抽象子类，将一个抽象子类的具体产品子类视为一组。产品族是指位于不同产品等级结构中，功能相关联的产品组成的家族。一般位于不同等级结构的相同位置上。每一个产品族中的产品数量与产品等级结构的数量相同。用户通过工厂以及族来判断

当用户使用时，必须知道哪个工厂以及哪个产品族的产品类，即通过组和族的二维坐标来确定具体的产品子类。每个工厂子类负责一族产品，且有一个方法来生成一种类型的产品。

举个例子说明。对于抽象工厂基类AbstractFactory派生了 3个具体的工厂类Factory1,Factory2,Factory3，则族数为3，即每个抽象产品类有3个具体子类。若有 2 个抽象产品类AbstractProductA,AbstractProductB，即2个组，则工厂类中有2个创建对象的函数createProductA,createProductB。

简单的实现：

class AbstractProductA{
public:
	virtual void fun() = 0;
	AbstractProductA(){}
	virtual ~AbstractProductA(){}

};
class ProductA_1 : public AbstractProductA{
public:
	virtual void fun(){cout<< "A_1"<<endl;}
	ProductA_1(){}
	virtual ~ProductA_1(){}
};
class ProductA_2 : public AbstractProductA{
public:
	virtual void fun(){cout<< "A_2"<<endl;}
	ProductA_2(){}
	virtual ~ProductA_2(){}
};
class ProductA_3 : public AbstractProductA{
public:
	virtual void fun(){cout<< "A_3"<<endl;}
	ProductA_3(){}
	virtual ~ProductA_3(){}
};

//B组
class AbstractProductB{
public:
	virtual void fun() = 0;
	AbstractProductB(){}
	virtual ~AbstractProductB(){}

};
class ProductB_1 : public AbstractProductB{
public:
	virtual void fun(){cout<< "B_1"<<endl;}
	ProductB_1(){}
	virtual ~ProductB_1(){}
};
class ProductB_2 : public AbstractProductB{
public:
	virtual void fun(){cout<< "B_2"<<endl;}
	ProductB_2(){}
	virtual ~ProductB_2(){}
};
class ProductB_3 : public AbstractProductB{
public:
	virtual void fun(){cout<< "B_3"<<endl;}
	ProductB_3(){}
	virtual ~ProductB_3(){}
};


class AbstractFactory{
public:
	AbstractFactory(){};
	virtual ~AbstractFactory();
	virtual AbstractProductA* createProductA() = 0;
	virtual AbstractProductB* createProductB() = 0;
};
class Factory1:public  AbstractFactory{
public:
	Factory1(){}
	~Factory1(){}
	AbstractProductA* createProductA(){return new ProductA_1();} 
	AbstractProductB* createProductB(){return new ProductB_1();} 
};
class Factory2:public  AbstractFactory{
public:
	Factory2(){}
	~Factory2(){}
	AbstractProductA* createProductA(){return new ProductA_2();} 
	AbstractProductB* createProductB(){return new ProductB_2();} 
};
class Factory3:public  AbstractFactory{
public:
	Factory3(){}
	~Factory3(){}
	AbstractProductA* createProductA(){return new ProductA_3();} 
	AbstractProductB* createProductB(){return new ProductB_3();} 
};

抽象工厂的用处，其原始意义是为了UNIX 和Windows，两者许多操作是相同的，这些相同的对象如File，Button等，这些东西分别为Windows族和Unix族各有一份，而对File这样对象的工厂类称Unixfile和Windowsfile为一组，进行结构化的划分。

抽象工厂支持不同类型的产品，更加方便的使用同一族中间的不同类型的产品。增加一族产品时，不修改工厂类和产品类的接口，不违背开闭原则。

缺点：结构过于臃肿，即使我只是简单实现，而3x2，就写了以上如此多的代码。如果产品组数变多或族数增加，都会使其难以管理。每次增加一组产品，工厂类和产品类接口都要修改，违背开闭原则。