设计模式C++达到 3.抽象工厂

简单工厂模式和工厂模式 要求 同类型的产品子类有共同的方法。这限制了产品子类的扩展。抽象工厂能client它提供了一个接口，它是client而不必指定产品的详细信息。创建多个产品系列产品对象。在归为一类相同的子类的产品抽象工厂类。让他们继承相同的抽象子类。子类视为一组。产品族是指位于不同产品等级结构中，功能相关联的产品组成的家族。

一般位于不同等级结构的同样位置上。每个产品族中的产品数量与产品等级结构的数量同样。用户通过工厂以及族来推断

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

举个样例说明。对于抽象工厂基类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，就写了以上如此多的代码。假设产品组数变多或族数添加，都会使其难以管理。

每加入产品的第二组，工厂类和产品类接口必须改变，相反，开闭原则。

版权声明：本文博主原创文章，博客，未经同意不得转载。