简单工厂模式和工厂模式 要求 同类型的产品子类有共同的方法。这限制了产品子类的扩展。抽象工厂能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，就写了以上如此多的代码。假设产品组数变多或族数添加，都会使其难以管理。

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