设计模式—创建型模式—AbstactFactory 模式（抽象工厂模式）

本主题相关博文均转自《设计模式精解－GoF 23 种设计模式解析附 C++实现源码》，作者：K_Eckel

问题 
假设我们要开发一款游戏，当然为了吸引更多的人玩，游戏难度不能太大（让大家都没有信心了，估计游戏也就没有前途了） ，但是也不能太简单（没有挑战性也不符合玩家的心理） 。于是我们就可以采用这样一种处理策略：为游戏设立等级，初级、中级、高级甚至有BT 级。假设也是过关的游戏，每个关卡都有一些怪物（monster）守着，玩家要把这些怪物干掉才可以过关。作为开发者，我们就不得不创建怪物的类，然后初级怪物、中级怪物等都继承自怪物类（当然不同种类的则需要另创建类，但是模式相同） 。在每个关卡，我们都要创建怪物的实例，例如初级就创建初级怪物（有很多种类） 、中级创建中级怪物等。可以想象在这个系统中， 将会有成千上万的怪物实例要创建， 问题是还要保证创建的时候不会出错：初级不能创建 BT 级的怪物（玩家就郁闷了，玩家一郁闷，游戏也就挂挂了） ，反之也不可以。 
 
AbstractFactory 模式就是用来解决这类问题的：要创建一组相关或者相互依赖的对象。

模式选择 
AbstractFactory 模式典型的结构图为：

                                                   图 2-1：AbstractFactory Pattern 结构图
AbstractFactory 模式关键就是将这一组对象的创建封装到一个用于创建对象的类（ConcreteFactory） 中， 维护这样一个创建类总比维护 n 多相关对象的创建过程要简单的多。  

实现 
完整代码示例（code） 
AbstractFactory 模式的实现比较简单，这里为了方便初学者的学习和参考，将给出完整的实现代码
代码片断 1：Product.h

//Product.h 
#ifndef _PRODUCT_H_ 
#define _PRODUCT_H_ 

class AbstractProductA 
{ 
public: 
	virtual ~AbstractProductA(); 
protected: 
	AbstractProductA(); 
private: 
}; 

class AbstractProductB 
{ 
public: 
	virtual ~AbstractProductB(); 
protected: 
	AbstractProductB();     private: 
}; 

class ProductA1:public AbstractProductA 
{ 
public: 
	ProductA1(); 
	~ProductA1(); 
protected: 
private: 
}; 

class ProductA2:public AbstractProductA 
{ 
public: 
	ProductA2(); 
	~ProductA2(); 
protected: 
private: 
}; 

class ProductB1:public AbstractProductB 
{ 
public: 
	ProductB1(); 
	~ProductB1(); 
protected: 
private: 
}; 

class ProductB2:public AbstractProductB 
{ 
public: 
	ProductB2(); 
	~ProductB2(); 
protected:
private: 
}; 

#endif //~_PRODUCT_H_ECT_H_ 

代码片断 2：Product.cpp

//Product.cpp 
#include "Product.h" 
#include <iostream> 
using namespace std; 

AbstractProductA::AbstractProductA() 
{    
} 

AbstractProductA::~AbstractProductA() 
{
} 

AbstractProductB::AbstractProductB() 
{
} 

AbstractProductB::~AbstractProductB() 
{
} 

ProductA1::ProductA1() 
{ 
	cout<<"ProductA1..."<<endl; 
} 

ProductA1::~ProductA1() 
{ 
} 

ProductA2::ProductA2() 
{ 
	cout<<"ProductA2..."<<endl; 
} 

ProductA2::~ProductA2() 
{ 
} 

ProductB1::ProductB1() 
{ 
	cout<<"ProductB1..."<<endl; 
} 

ProductB1::~ProductB1() 
{ 
} 

ProductB2::ProductB2() 
{ 
	cout<<"ProductB2..."<<endl; 
} 

ProductB2::~ProductB2() 
{ 
}

代码片断 3：AbstractFactory.h

//AbstractFactory.h 
#ifndef _ABSTRACTFACTORY_H_ 
#define _ABSTRACTFACTORY_H_ 

class AbstractProductA; 
class AbstractProductB; 
class AbstractFactory 
{ 
public: 
	virtual ~AbstractFactory(); 
	virtual 
		AbstractProductA* 
		CreateProductA() = 0; 
	virtual 
		AbstractProductB* 
		CreateProductB() = 0; 
protected: 
	AbstractFactory(); 
private: 
}; 

class ConcreteFactory1:public AbstractFactory 
{ 
public: 
	ConcreteFactory1(); 
	~ConcreteFactory1(); 
	AbstractProductA* CreateProductA(); 
	AbstractProductB* CreateProductB(); 
protected: 
private: 
}; 

class ConcreteFactory2:public AbstractFactory 
{ 
public: 
	ConcreteFactory2(); 
	~ConcreteFactory2(); 
	AbstractProductA* CreateProductA(); 
	AbstractProductB* CreateProductB(); 
protected: 
private: 
}; 

#endif //~_ABSTRACTFACTORY_H_

代码片断 4：AbstractFactory.cpp

//AbstractFactory.cpp 
#include "AbstractFactory.h" 
#include "Product.h" 
#include <iostream> 
using namespace std; 

AbstractFactory::AbstractFactory() 
{
} 

AbstractFactory::~AbstractFactory() 
{
}

ConcreteFactory1::ConcreteFactory1() 
{ 
}

ConcreteFactory1::~ConcreteFactory1() 
{ 
} 

AbstractProductA* ConcreteFactory1::CreateProductA() 
{ 
	return new ProductA1(); 
} 

AbstractProductB* ConcreteFactory1::CreateProductB() 
{ 
	return new ProductB1(); 
} 

ConcreteFactory2::ConcreteFactory2() 
{ 
} 

ConcreteFactory2::~ConcreteFactory2() 
{ 
} 

AbstractProductA* ConcreteFactory2::CreateProductA() 
{ 
	return new ProductA2(); 
} 

AbstractProductB* ConcreteFactory2::CreateProductB() 
{ 
	return new ProductB2(); 
}

代码片断 5：main.cpp

//main.cpp 
#include "AbstractFactory.h" 
#include <iostream> 
using namespace std; 

int main(int argc,char* argv[]) 
{ 
	AbstractFactory* cf1 = new ConcreteFactory1(); 
	cf1->CreateProductA(); 
	cf1->CreateProductB(); 

	AbstractFactory* cf2 = new ConcreteFactory2(); 
	cf2->CreateProductA(); 
	cf2->CreateProductB(); 

	return 0; 
} 

代码说明:
AbstractFactory 模式的实现代码很简单，在测试程序中可以看到，当我们要创建一组对象（ProductA1，ProductA2）的时候我们只用维护一个创建对象（ConcreteFactory1） ，大大简化了维护的成本和工作。

讨论 
AbstractFactory 模式和 Factory 模式的区别是初学（使用）设计模式时候的一个容易引起困惑的地方。实际上，AbstractFactory 模式是为创建 一组（有多类）相关或依赖的对象提供创建接口，而 Factory 模式正如我在相应的文档中分析的是为 一类对象提供创建接口或延迟对象的创建到子类中实现。并且可以看到，AbstractFactory 模式通常都是使用 Factory 模式实现（ConcreteFactory1） 。