c++设计模式之工厂模式

前言

工厂模式是23种设计模式中用的频率比较高，同时也是较为简单的模式。工厂模式，顾名思义，是一种创建型的模式，其实现方式有三种，分别是简单工厂模式，工厂方法模式和抽象工厂方法。

简单工厂

简单工厂模式又称静态工厂方法模式，是最简单的一种工厂模式。简单工厂模式是通过传入参数给工厂对象，指定创建某一种产品实例。简单工厂模式的UML图如下：

接下来看一个例子，以生产电脑为例，假设有一个工厂可以生产联想和戴尔两种电脑，具体生产哪种由老板决定。具体代码如下：

#include <iostream>
using namespace std;
enum eComputer{
	lenovo,
	dell
}; 
class Computer{
	public:
		virtual void show() = 0;
}; 
class Lenovo:public Computer{
	public:
		void show()
		{
			cout << "Lenovo" << endl;
		}
};
class Dell:public Computer{
	public:
		void show()
		{
			cout << "Dell" << endl;
		}
};
class Factory{
	public:
		Computer* createproduct(eComputer type)
		{
			switch(type)
			{
				case lenovo:
					return new Lenovo;
					break;
				case dell:
					return new Dell;
					break;
				default:
					break;
			}
		}
};
int main()
{
	Factory* fp = new Factory(); //创建一个工程
	fp->createproduct(lenovo)->show();//老板说生产联想
	fp->createproduct(dell)->show();//老板说生产戴尔
	return 0;
}

程序输出结果：

由上例可以看出简单工厂模式的缺点很明显：如果需要增加产品，就需要修改工厂类中的代码，违反了开闭原则。

工厂方法模式

工厂模式不仅仅是提供了创建了对象的接口，更重要的是延迟了子类的实例化。核心的工厂类将会成为一个抽象类，具体的创建工作交由子类来完成，这么做的一个好处就是当需要增加产品时，不需要修改核心工厂的代码即可完成。
在该模式中，工厂和产品通常是一一对应关系。
还是由生产电脑的例子来演示工厂方法。由于工厂收入很客观，因此老板决定再做两个工厂，分别单独生产联想电脑和戴尔电脑，以后生产电脑的工作交由两个子工厂分别负责，一开始两个工厂也不知道怎么生产联想和戴尔的电脑，因此他们需要从总工厂学习（继承）生产电脑的方法。接下来看一下具体的代码。

#include <iostream>
using namespace std;
enum eComputer{
	lenovo,
	dell
}; 
class Computer{
	public:
		virtual void show() = 0;
}; 
class Lenovo:public Computer{
	public:
		void show()
		{
			cout << "Lenovo" << endl;
		}
};
class Dell:public Computer{
	public:
		void show()
		{
			cout << "Dell" << endl;
		}
};
class Factory{
	public:
		virtual Computer* create() = 0;
};

class LenovoFactory:public Factory{
	public:
		Computer* create()
		{
			return new Lenovo();
		}
};

class DellFactory:public Factory{
	public:
		Computer* create()
		{
			return new Dell();
		}
};	

int main()
{
	
	LenovoFactory* lf = new  LenovoFactory();//创建联想工厂
	DellFactory*   dl = new DellFactory();//创建戴尔工厂
	lf->create()->show();
	dl->create()->show();
	delete lf;
	delete dl;
	return 0;
}

工厂方法缺点也很明显，每增加一个产品就需要增加一个新的工厂。

抽象工厂模式

现在考虑一下假设之前生产的联想是A型号，现在又需要生产B型号的联想，需要增加新的工厂的吗？答案是不需要。做法也很简单，只需要在核心工厂中提供生产B型号电脑的方法，联想工厂则可以生产出B型号的脸型电脑。可以看出，抽象工厂可以让每一个工厂分别生产其产品的各个型号。
先来看一下具体的实现：

#include <iostream>
using namespace std;
enum eComputer{
	lenovo,
	dell
}; 
class ProductA{
	public:
		virtual void show() = 0;
}; 
class Lenovo_A:public ProductA{
	public:
		void show()
		{
			cout << "Lenovo_A" << endl;
		}
};
class Dell_A:public ProductA{
	public:
		void show()
		{
			cout << "Dell_A" << endl;
		}
};
class ProductB{
	public:
		virtual void show() = 0;
}; 
class Lenovo_B:public ProductB{
	public:
		void show()
		{
			cout << "Lenovo_B" << endl;
		}
};
class Dell_B:public ProductB{
	public:
		void show()
		{
			cout << "Dell_B" << endl;
		}
};
class Factory{
	public:
		virtual ProductA* createA() = 0;
		virtual ProductB* createB() = 0;
 };

class LenovoFactory:public Factory{
	public:
		ProductA* createA()
		{
			return new Lenovo_A();
		}
		ProductB* createB()
		{
			return new Lenovo_B();
		}
};

class DellFactory:public Factory{
	public:
		ProductA* createA()
		{
			return new Dell_A();
		}
		ProductB* createB()
		{
			return new Dell_B();
		}
};	

int main()
{
	LenovoFactory *lf = new LenovoFactory();//创建联想工厂
	lf->createA()->show();//生产A型号
	lf->createB()->show();//生产B型号
	
	DellFactory *df = new DellFactory();//创建戴尔工厂
	df->createA()->show();//生产A型号
	df->createB()->show();//生产B型号
	
	delete lf;
	delete df;
	return 0;
}

运行结果如下所示：

如此一来，就可以使用一个具体的工厂管理一个多种型号的产品。