首页 > 代码库 > 设计模式的C++实现 3.抽象工厂

设计模式的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,就写了以上如此多的代码。如果产品组数变多或族数增加,都会使其难以管理。每次增加一组产品,工厂类和产品类接口都要修改,违背开闭原则。



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