工厂模式详解：从简单工厂到抽象工厂-优快云博客

工厂模式属于创建型模式，大致可以分为三类，简单工厂模式、工厂方法模式、抽象工厂模式。听上去差不多，都是工厂模式。

1、简单工厂模式

它的主要特点是需要在工厂类中做判断，从而创造相应的产品。当增加新的产品时，就需要修改工厂类。有点抽象，举个例子就明白了。有一家生产处理器核的厂家，它只有一个工厂，能够生产两种型号的处理器核。客户需要什么样的处理器核，一定要显示地告诉生产工厂。下面给出一种实现方案。

#include <iostream>
using namespace std;

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)  
	{  
		if(ctype == COREA) //工厂内部判断  
		return new SingleCoreA(); //生产核A  
		else if(ctype == COREB)  
			return new SingleCoreB(); //生产核B  
		else  
			return NULL;  
	}  
};  

int main(void)
{
	Factory* factory = new Factory();
	factory->CreateSingleCore(COREA)->Show();
	factory->CreateSingleCore(COREB)->Show();
}

缺点：就是要增加新的核类型时，就需要修改工厂类。这就违反了开放封闭原则：（对扩展开放；对修改封闭）。于是，工厂方法模式出现了。

2、工厂方法模式

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

听起来很抽象，还是以刚才的例子解释。这家生产处理器核的产家赚了不少钱，于是决定再开设一个工厂专门用来生产B型号的单核，而原来的工厂专门用来生产A型号的单核。这时，客户要做的是找好工厂，比如要A型号的核，就找A工厂要；否则找B工厂要，不再需要告诉工厂具体要什么型号的处理器核了。下面给出一个实现方案。

#include <iostream>
using namespace std;

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;
};  
//生产A核的工厂  
class FactoryA: public Factory  
{  
public:  
	SingleCore* CreateSingleCore() { return new SingleCoreA; }  
};  
//生产B核的工厂  
class FactoryB: public Factory  
{  
public:  
	SingleCore* CreateSingleCore() { return new SingleCoreB; }  
};  

int main(void)
{
	FactoryA* factorya = new FactoryA();
	factorya->CreateSingleCore()->Show();
	FactoryB* factoryb = new FactoryB();
	factoryb->CreateSingleCore()->Show();
	return 0;
}

工厂方法模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

1、在设计的初期，就考虑到产品在后期会进行扩展的情况下，可以使用工厂方法模式；

2、产品结构较复杂的情况下，可以使用工厂方法模式；

缺点，每增加一种产品，就需要增加一个对象的工厂。如果这家公司发展迅速，推出了很多新的处理器核，那么就要开设相应的新工厂。在C++实现中，就是要定义一个个的工厂类。显然，相比简单工厂模式，工厂方法模式需要更多的类定义。

既然有了简单工厂模式和工厂方法模式，为什么还要有抽象工厂模式呢？它到底有什么作用呢？还是举这个例子，这家公司的技术不断进步，不仅可以生产单核处理器，也能生产多核处理器。现在简单工厂模式和工厂方法模式都鞭长莫及。抽象工厂模式登场了。

3、抽象工厂模式

定义为提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。具体这样应用，这家公司还是开设两个工厂，一个专门用来生产A型号的单核、多核处理器，而另一个工厂专门用来生产B型号的单核、多核处理器，下面给出实现的代码。

#include <iostream>
using namespace std;

//单核  
class SingleCore   
{  
public:  
	virtual void Show() = 0;
};  
class SingleCoreA: public SingleCore    
{  
public:  
	void Show() { cout<<"Single Core A"<<endl; }  
};  
class SingleCoreB :public SingleCore  
{  
public:  
	void Show() { cout<<"Single Core B"<<endl; }  
};  
//多核  
class MultiCore    
{  
public:  
	virtual void Show() = 0;
};  
class MultiCoreA : public MultiCore    
{  
public:  
	void Show() { cout<<"Multi Core A"<<endl; }  

};  
class MultiCoreB : public MultiCore    
{  
public:  
	void Show() { cout<<"Multi Core B"<<endl; }  
};  
//工厂  
class CoreFactory    
{  
public:  
	virtual SingleCore* CreateSingleCore() = 0;
	virtual MultiCore* CreateMultiCore() = 0;
};  
//工厂A，专门用来生产A型号的处理器  
class FactoryA :public CoreFactory  
{  
public:  
	SingleCore* CreateSingleCore() { return new SingleCoreA(); }  
	MultiCore* CreateMultiCore() { return new MultiCoreA(); }  
};  
//工厂B，专门用来生产B型号的处理器  
class FactoryB : public CoreFactory  
{  
public:  
	SingleCore* CreateSingleCore() { return new SingleCoreB(); }  
	MultiCore* CreateMultiCore() { return new MultiCoreB(); }  
}; 

//主函数测试抽象工厂
int main(void)
{
	FactoryA* factorya = new FactoryA();
	factorya->CreateSingleCore()->Show();
	factorya->CreateMultiCore()->Show();
	FactoryB* factoryb = new FactoryB();
	factoryb->CreateSingleCore()->Show();
	factoryb->CreateMultiCore()->Show();

	return 0;
}

要点

1. 抽象工厂应用场景：

1) 一个系统要独立于它的产品的创建、组合和表示时。

2) 一个系统要由多个产品系列中的一个来配置时。

3) 当你要强调一系列相关的产品对象的设计以便进行联合使用时。

4) 当你提供一个产品类库，而只想显示它们的接口而不是实现时。

2. 新增产品复杂。抽象工厂增加产品组件时，需要更改所有工厂的接口。如增加A型号N核处理器时，则工厂基类和具体工厂需要增加接口CreateNCore。

3. 抽象工厂模式与工厂方法模式的区别。

a．重点不同。工厂方法模式强调的是不同的创建者根据自身需求去生产不同的具体产品，重点是生产具体产品；而抽象工厂模式则定位为“在不指定实体类别的前提下，提供了一个可以创建一系列相关或互相依赖之组件的接口”，重点是创建相关组件。

b．抽象工厂提供了的“相关组件”可以看成是具体的产品，抽象工厂模式的“相关组件”可由工厂模式实现。FactoryA. CreateSingleCore生产的具体产品，可以用工厂方法模式实现，即每一个产品用一个工厂方法实现。

c．工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

d．抽象工厂不能直接创建产品，只能创建工厂，即抽象工厂创建的产品是工厂。虽然它也定义了创建产品的方法，但需要创建出来的具体的工厂实现，即抽象工厂创建出的工厂创建产品。