【设计模式C++】工厂模式

设计模式系列学习自：http://blog.csdn.net/wuzhekai1985/article/category/859763（wuzhekai的专栏）

软件领域中的设计模式为开发人员提供了一种使用专家设计经验的有效途径。设计模式中运用了面向对象编程语言的重要特性：封装、继承、多态，真正领悟设计模式的精髓是可能一个漫长的过程，需要大量实践经验的积累。

正如《大话设计模式》里说的，我们打着C++的旗帜却干着面向过程的事，为了更好的理解OO语言的精华，我要开始学习设计模式。

这篇文章主要介绍工厂模式。

 

工厂模式属于创建型模式，大致可以分为三类：

1）简单工厂模式（Simple Factory）

一个抽象产品类，可以派生出多个具体产品类。   
一个具体工厂类，可以创建多种具体产品的实例。 

2）工厂方法模式（Factory Method） 

一个抽象产品类，可以派生出多个具体产品类。   
一个抽象工厂类，可以派生出多个具体工厂类。   
每个具体工厂类只能创建一个具体产品类的实例

3）抽象工厂模式（Abstract Factory） 

多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。   
一个抽象工厂类，可以派生出多个具体工厂类。   
每个具体工厂类可以创建多个具体产品类的实例。  

下面一个个介绍，首先介绍简单工厂模式，它的主要特点是需要在工厂类中做判断，从而创造相应的产品。当增加新的产品时，就需要修改工厂类。比如有一家生产处理器核的厂家，它只有一个工厂，能够生产两种型号的处理器核。客户需要什么样的处理器核，一定要显示地告诉生产工厂。下面给出一种实现方案。

enum CTYPE {COREA, COREB};   
//抽象核
class SingleCore  
{  
public:  
    virtual void Show() = 0;
};  
//单核A  
class SingleCoreA: public SingleCore  
{  
public:  
    void Show() { cout << "SingleCore A" << endl; }  
};  
//单核B  
class SingleCoreB: public SingleCore  
{  
public:  
    void Show() { cout << "SingleCore B" << endl; }  
};  
//唯一的工厂，可以生产两种型号的处理器核，在内部判断  
class Factory  
{  
public:   
    SingleCore* CreateSingleCore(enum CTYPE ctype)  
    {  
		switch (ctype)		//工厂内部判断
		{		
        	case COREA:   
            		return new SingleCoreA();	//生产核A  
        	case COREB:  
            		return new SingleCoreB();	//生产核B 
		defalt:
			return NULL;	
    	}	
    }	
};  

这样设计的主要缺点是当要增加新的核类型时，就需要修改工厂类，这就违反了开放封闭原则，即对扩展是开放的，对修改是关闭的。

于是，工厂方法模式出现了。所谓工厂方法模式，是指定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。

继续以上面为例，这家生产处理器核的产家赚了不少钱，于是决定再开设一个工厂专门用来生产B型号的单核，而原来的工厂专门用来生产A型号的单核。这时，客户要做的是找好工厂，比如要A型号的核，就找A工厂要；否则找B工厂要，不再需要告诉工厂具体要什么型号的处理器核了。

//抽象核
class SingleCore  
{  
public:  
    virtual void Show() = 0
};  
//单核A  
class SingleCoreA: public SingleCore  
{  
	public:  
    	void Show() { cout << "SingleCore A" << endl; }  
};  
//单核B  
class SingleCoreB: public SingleCore  
{  
	public:  
    	void Show() { cout << "SingleCore B" << endl; }  
};  
//抽象工厂
class Factory  
{  
	public:   
    	virtual SingleCore* CreateSingleCore() = 0;
};  

class FactoryA: public Factory
{
	public:
		SingleCoreA* CreateSingleCore(){return new SingleCoreA;}
};
class FactoryB: public Factory
{
	public:
		SingleCoreB* CreateSingleCore(){return new SingleCoreB;}
};

工厂方法模式也有缺点，每增加一种产品，就需要增加一个对象的工厂。如果这家公司发展迅速，推出了很多新的处理器核，那么就要开设相应的新工厂。在C++实现中，就是要定义一个个的工厂类。显然，相比简单工厂模式，工厂方法模式需要更多的类定义。
       既然有了简单工厂模式和工厂方法模式，为什么还要有抽象工厂模式呢？它到底有什么作用呢？还是举这个例子，这家公司的技术不断进步，不仅可以生产单核处理器，也能生产多核处理器。现在简单工厂模式和工厂方法模式都鞭长莫及。抽象工厂模式登场了。它的定义为提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。具体这样应用，这家公司还是开设两个工厂，一个专门用来生产A型号的单核多核处理器，而另一个工厂专门用来生产B型号的单核多核处理器，下面给出实现的代码。

//抽象单核
class SingleCore  
{  
	public:  
    	virtual void Show() = 0;
}; 
//抽象多核
class MultiCore
{
	public:
		virtual void Show() = 0;
};

//单核A  
class SingleCoreA: public SingleCore  
{  
	public:  
    	void Show() { cout << "SingleCore A" << endl; }  
};  
//单核B  
class SingleCoreB: public SingleCore  
{  
	public:  
    	void Show() { cout << "SingleCore B" << endl; }  
}; 
//多核A
class MultiCoreA: public MultiCore
{
	public:
		void Show() { cout << "MultiCore A" << endl;}
};
//多核B
class MultiCoreB: public MultiCore
{
	public:
		void Show() { cout << "MultiCore B" << endl;}
};

//抽象工厂
class Factory  
{  
	public:
		virtual SingleCore* CreateSingleCore() = 0;
		virtual MultiCore* CreateMultiCore() = 0;

};  
//工厂A
class FactoryA: public Factory
{
	public:
		SingleCoreA* CreateSingleCore() { return new SingleCoreA;}
		MultiCoreA*	CreateMultiCore() { return new MultiCoreA;}
};
//工厂B
class FactoryB: public Factory
{
	public:
		SingleCoreB* CreateSingleCore() { return new SingleCoreB;}
		MultiCoreB* CreateMultiCore() { return new MultiCoreB;}
};

至此，工厂模式介绍完了。下面给出三种工厂模式的UML图，加深印象。

简单工厂模式的UML图：

工厂方法模式的UML图：

抽象工厂模式的UML图：