C++---抽象工厂模式

模式简介

抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。通俗的来说就是一个工厂个可以产不同品种的产品，但是来自同一工厂的产品之间必须有一定的关系，即例子中有A1产品那么必须有B1产品。

产品族

是指位于不同产品等级结构中，功能相关联的产品组成的家族。一般是位于不同的等级结构中的相同位置上。

模式实现

抽象工厂模式提供两个具体工厂角色，分别对应于这两个具体产品角色，每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。

代码示例

                                  

class ProductA//抽象A产品类 
{
public:
	ProductA(std::string name) :mname(name){}
	virtual void operation() = 0;
	virtual ~ProductA(){}
protected:
	std::string mname;
};
class ProductA1 :public ProductA//A产品中的一个子产品A1 
{
public:
	ProductA1(std::string name) :ProductA(name){}
	virtual void operation()
	{
		std::cout << "A1" << std::endl;
	}
protected:
	std::string mname;
};
class ProductA2 :public ProductA//A产品中的一个子产品A2
{
public:
	ProductA2(std::string name) :ProductA(name){}
	virtual void operation()
	{
		std::cout << "A2" << std::endl;
	}
protected:
	std::string mname;
};
class ProductB//抽象A产品类 
{
public:
	ProductB(std::string name) :mname(name){}
	virtual void operation() = 0;
	virtual ~ProductB(){}
protected:
	std::string mname;
};
class ProductB1 :public ProductB//B产品中的一个子产品B1 
{
public:
	ProductB1(std::string name) :ProductB(name){}
	virtual void operation()
	{
		std::cout << "B1" << std::endl;
	}
protected:
	std::string mname;
};
class ProductB2 :public ProductB//B产品中的一个子产品B2 
{
public:
	ProductB2(std::string name) :ProductB(name){}
	virtual void operation()
	{
		std::cout << "B2" << std::endl;
	}
protected:
	std::string mname;
};

class AbstractFactory//抽象工厂 
{
public:
	virtual ProductA* createProductA() = 0;
	virtual ProductB* createProductB() = 0;
	virtual ~AbstractFactory(){}
};
class Factory_1 :public AbstractFactory//抽象工厂1 
{
public:
	virtual ProductA* createProductA()
	{
		return new ProductA1("PA1");
	}
	virtual ProductB* createProductB()
	{
		return new ProductB1("PB1");
	}
};
class Factory_2 :public AbstractFactory//工厂2 
{
public:
	virtual ProductA* createProductA()
	{
		return new ProductA2("PA2");
	}
	virtual ProductB* createProductB()
	{
		return new ProductB2("PB2");
	}
};

int main()
{
	AbstractFactory* paf = new Factory_2();//基类抽象工厂类的指针指向派生类对象工厂2
	ProductB* pa = paf->createProductB();//产品B类型的指针接收函数 createProductB()产生的对象B2 
	pa->operation();
	delete pa;
	delete paf;
	return 0;
}