[C++设计模式] factory 工厂模式

说的直接点，工厂模式就是接管对象的创建，在new()的同时既可以做额外的异常处理、初始化等操作，又可以降低模块间的耦合，方便维护和拓展。

根据创建对象的复杂度，可以分为简单工厂模式、工厂法模式和抽象工厂模式。

一、简单工厂模式

ProductA、ProductB和ProductC继承自Product虚拟类，Show方法是不同产品的自描述；Factory依赖于ProductA、ProductB和ProductC，Factory根据不同的条件创建不同的Product对象。

typedef enum ProductTypeTag
{
	TypeA,
	TypeB,
	TypeC
}PRODUCTTYPE;

// Here is the product class
class Product
{
public:
	virtual void Show() = 0;
};

class ProductA : public Product
{
public:
	void Show()
	{
		cout<<"I'm ProductA"<<endl;
	}
};

class ProductB : public Product
{
public:
	void Show()
	{
		cout<<"I'm ProductB"<<endl;
	}
};

class ProductC : public Product
{
public:
	void Show()
	{
		cout<<"I'm ProductC"<<endl;
	}
};

// Here is the Factory class
class Factory
{
public:
	Product* CreateProduct(PRODUCTTYPE type)
	{
		switch (type)
		{
		case TypeA:
			return new ProductA();

		case TypeB:
			return new ProductB();

		case TypeC:
			return new ProductC();

		default:
			return NULL;
		}
	}
};

简单的对继承自虚基类product的三种类的对象创建的封装，约束是：productA、productB、productC都是继承自product的类型，可以利用多态特性。

另外，只有一种product子类，也属于简单工厂模式。

二、工厂法模式

由于简单工厂模式的局限性，比如：工厂现在能生产ProductA、ProductB和ProductC三种产品了，此时，需要增加生产ProductD产品；那么，首先是不是需要在产品枚举类型中添加新的产品类型标识，然后，修改Factory类中的switch结构代码。是的，这种对代码的修改，对原有代码的改动量较大。出于种种原因，简单工厂模式，在实际项目中使用的较少。

那该怎么办？
《head first》中以制作pizza为例，定义了一个虚基类pizzaStore，内含一个纯虚函数createpizza（），通过继承这个虚基类重载createpizza（）就可以制作出口味不同的pizza。
工厂方法模式是在简单工厂模式的基础上，对“工厂”添加了一个抽象层。将工厂共同的动作抽象出来，作为抽象类，而具体的行为由子类本身去实现，让子类去决定生产什么样的产品。

这样，想增加一种产品productC，只需继承抽象层factory建造一个新的工厂factoryC，来制造新的产品。原来已有的工厂不需要修改。工厂方法模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

class Product
{
public:
	virtual void Show() = 0;
};

class ProductA : public Product
{
public:
	void Show()
	{
		cout<< "I'm ProductA"<<endl;
	}
};

class ProductB : public Product
{
public:
	void Show()
	{
		cout<< "I'm ProductB"<<endl;
	}
};

class Factory
{
public:
	virtual Product *CreateProduct() = 0;
};

class FactoryA : public Factory
{
public:
	Product *CreateProduct()
	{
		return new ProductA ();
	}
};

class FactoryB : public Factory
{
public:
	Product *CreateProduct()
	{
		return new ProductB ();
	}
};

三、抽象工厂模式

我们可能会想到，后期产品会越来越多了，建立的工厂也会越来越多，工厂进行了增长，工厂变的凌乱而难于管理；由于工厂方法模式创建的对象都是继承于Product的，所以工厂方法模式中，每个工厂只能创建单一种类的产品，当需要生产一种全新的产品（不继承自Product）时，发现工厂方法是心有余而力不足。

工厂方法模式适用于产品种类结构单一的场合，为一类产品提供创建的接口；而抽象工厂方法适用于产品种类结构多的场合，主要用于创建一组（有多个种类）相关的产品，为它们提供创建的接口；就是当具有多个抽象角色时，抽象工厂便可以派上用场。

class ProductA
{
public:
	virtual void Show() = 0;
};

class ProductA1 : public ProductA
{
public:
	void Show()
	{
		cout<<"I'm ProductA1"<<endl;
	}
};

class ProductA2 : public ProductA
{
public:
	void Show()
	{
		cout<<"I'm ProductA2"<<endl;
	}
};

// Product B
class ProductB
{
public:
	virtual void Show() = 0;
};

class ProductB1 : public ProductB
{
public:
	void Show()
	{
		cout<<"I'm ProductB1"<<endl;
	}
};

class ProductB2 : public ProductB
{
public:
	void Show()
	{
		cout<<"I'm ProductB2"<<endl;
	}
};

// Factory
class Factory
{
public:
	virtual ProductA *CreateProductA() = 0;
	virtual ProductB *CreateProductB() = 0;
};

class Factory1 : public Factory
{
public:
	ProductA *CreateProductA()
	{
		return new ProductA1();
	}

	ProductB *CreateProductB()
	{
		return new ProductB1();
	}
};

class Factory2 : public Factory
{
	ProductA *CreateProductA()
	{
		return new ProductA2();
	}

	ProductB *CreateProductB()
	{
		return new ProductB2();
	}
};