C++设计模式——创建型模式之工厂模式

简单工厂模式

为了提高内聚和松耦合，我们经常会抽象出一些类的公共接口以形成抽象基类或者接口；这样可以通过声明一个指向基类的指针指向实际的子类来实现，达到多态的目的；但是当子类对象很多时，就会给创建带来麻烦，并造成扩展性和维护性困难。

简单工厂是对类的创建进行封装，通过参数来控制子类对象的创建。

class Product {};
class ProductA : public Product{};
class ProductB : public Product {};
class ProductC : public Product {};

enum PRODUCTTYPE
{
	TypeA,
	TypeB,
	TypeC
};

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 nullptr;
		}
	}
};

工厂方法模式

在理解工厂模式之前，先思考如下两个问题：

• 为了提高内聚和松耦合，我们经常会抽象出一些类的公共接口以形成抽象基类或者接口；这样可以通过声明一个指向基类的指针指向实际的子类来实现，达到多态的目的；但是当子类对象很多时，就会给创建带来麻烦，并造成扩展性和维护性困难。
• 当我们在基类中使用另外一个类B，但是具体的创建是在子类中根据实际的需要进行创建，这时需要将具体化类的工作延迟到子类来完成。

通过工厂方法模式可以解决上述两个问题，工厂方法模式在简单工厂模式的基础上增加对工厂的基类抽象，不同的产品创建采用不同的工厂创建（从工厂的抽象基类派生），这样创建不同的产品过程就由不同的工厂分工解决：FactoryA专心负责生产ProductA，FactoryB专心负责生产ProductB，FactoryA和FactoryB之间没有关系；如果到了后期，如果需要生产ProductC时，我们则可以创建一个FactoryC工厂类，该类专心负责生产ProductC类产品。

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

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

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

class FactoryC : public FactoryMethod
{
public:
	virtual Product* CreateProduct()
	{
		return new ProductC();
	}
};

对于简单工厂和工厂方法的问题：

• 对于每新添加一个product，都会导致createProduct变得臃肿和缺少封闭性（简单工厂）或 添加新的factory来创建新的Product最为代价。
• Factory模式仅仅局限于一类的类型，即都有共同的基类，当我们需要为不同的类创建提供一个对象接口，那么就需要使用到抽象工厂模式。

抽象工厂模式

简单的说：AbstractFactory模式就是用来解决要创建一组相关或者相互依赖的对象。

抽象工厂模式，下面不妨将ProductA当作上衣的选择，ProductB当作裤子的选择，Factory就是要做相应的搭配，在Factory中可以根据需要自行选择搭配方式。

#include <iostream>
using namespace std;

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

class ProductA1 : public ProductA
{
public:
	void Func1()
	{
		cout << "ProductA1::Func1" << endl;
	}
};
class ProductA2 : public ProductA
{
public:
	void Func1()
	{
		cout << "ProductA2::Func1" << endl;
	}
};

class ProductB
{
public:
	virtual void Func2() = 0;
};
class ProductB1 : public ProductB
{
public:
	void Func2()
	{
		cout << "ProductB1::Func2" << endl;
	}
};
class ProductB2 : public ProductB
{
public:
	void Func2()
	{
		cout << "ProductB2::Func2" << endl;
	}
};
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();
	}
};

总结：

AbstractFactory模式是为创建一组（有多类）相关或依赖的对象提供创建接口；

Factory模式正如我在相应的文档中分析的是为一类对象提供创建接口或延迟对象的创建到子类中实现；

AbstractFactory模式通常都是使用Factory模式实现。