前言
假设我们要开发一款游戏，当然为了吸引更多的人玩，游戏难度不能太大（让大家都没有信心了，估计游戏也就没有前途了），但是也不能太简单（没有挑战性也不符合玩家的心。理）。于是我们就可以采用这样一种处理策略：为游戏设立等级，初级、中级、高级甚至有BT 级。假设也是过关的游戏，每个关卡都有一些怪物（monster）守着，玩家要把这些怪物干掉才可以过关。作为开发者，我们就不得不创建怪物的类，然后初级怪物、中级怪物等都继承自怪物类（当然不同种类的则需要另创建类，但是模式相同）。在每个关卡，我们都要创建怪物的实例，例如初级就创建初级怪物（有很多种类）、中级创建中级怪物等。可以想象在这个系统中，将会有成千上万的怪物实例要创建，问题是还要保证创建的时候不会出错：初级不能创建 BT 级的怪物（玩家就郁闷了，玩家一郁闷，游戏也就挂挂了），反之也不可以。
AbstractFactory 模式就是用来解决这类问题的：要创建一组相关或者相互依赖的对象。
一、抽象工厂模式(AbstactFactory 模式)
AbstractFactory 模式关键就是将这一组对象的创建封装到一个用于创建对象的类 （ConcreteFactory）中，维护这样一个创建类总比维护 n 多相关对象的创建过程要简单的多。下面是对应的UML图：
二、具体源码
1.Product.h
代码如下（示例）：
#ifndef _PRODUCT_H_
#define _PRODUCT_H_
#include <iostream>
//定义抽象产品类A
class AbstractProductA
{
public:
//析构函数定义为虚函数
//作用：虚析构函数使得在删除指向子类对象的基类指针时可以调用子类的析构函数达到释放子类中堆内存的目的，而防止内存泄露的
virtual ~AbstractProductA();
protected:
AbstractProductA();
private:
};
//定义抽象产品类B
class AbstractProductB
{
public:
virtual ~AbstractProductB();
protected:
AbstractProductB();
private:
};
//定义具体的产品类A1
class ProductA1 :public AbstractProductA
{
public:
ProductA1();
~ProductA1();
protected:
private:
};
//定义具体的产品类A2
class ProductA2 :public AbstractProductA
{
public:
ProductA2();
~ProductA2();
protected:
private:
};
//定义具体的产品类B1
class ProductB1 :public AbstractProductB
{
public:
ProductB1();
~ProductB1();
protected:
private:
};
//定义具体的产品类B2
class ProductB2 :public AbstractProductB
{
public:
ProductB2();
~ProductB2();
protected:
private:
};
#endif //PRODUCT_H
2.Product.cpp
代码如下（示例）：
#include "Product.h"
AbstractProductA::AbstractProductA()
{
}
AbstractProductA::~AbstractProductA()
{
}
AbstractProductB::AbstractProductB()
{
}
AbstractProductB::~AbstractProductB()
{
}
ProductA1::ProductA1()
{
std::cout << "ProductA1..." << std::endl;
}
ProductA1::~ProductA1()
{
}
ProductA2::ProductA2()
{
std::cout << "ProductA2..." << std::endl;
}
ProductA2::~ProductA2()
{
}
ProductB1::ProductB1()
{
std::cout << "ProductB1..." << std::endl;
}
ProductB1::~ProductB1()
{
}
ProductB2::ProductB2()
{
std::cout << "ProductB2..." << std::endl;
}
ProductB2::~ProductB2()
{
}
3.AbstractFactory.h
代码如下（示例）：
#ifndef _ABSTRACTFACTORY_H_
#define _ABSTRACTFACTORY_H_
#include "Product.h"
//定义工厂的接口，无法实例化
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
代码如下（示例）：
#include "AbstractFactory.h"
AbstractFactory::AbstractFactory()
{
}
AbstractFactory::~AbstractFactory()
{
}
ConcreteFactory1::ConcreteFactory1()
{
}
ConcreteFactory1::~ConcreteFactory1()
{
}
AbstractProductA* ConcreteFactory1::CreateProductA()
{
//创建具体产品子类A1的智能指针，防止内存被消除
std::shared_ptr<ProductA1> ptr = std::make_shared<ProductA1>();
//将子类指针转化为父类指针
return dynamic_cast<AbstractProductA*>(ptr.get());
}
AbstractProductB* ConcreteFactory1::CreateProductB()
{
//创建具体产品子类B1的智能指针，防止内存被消除
std::shared_ptr<ProductB1> ptr = std::make_shared<ProductB1>();
//将子类指针转化为父类指针
return dynamic_cast<AbstractProductB*>(ptr.get());
}
ConcreteFactory2::ConcreteFactory2()
{
}
ConcreteFactory2::~ConcreteFactory2()
{
}
AbstractProductA* ConcreteFactory2::CreateProductA()
{
//创建具体产品子类A2的智能指针，防止内存被消除
std::shared_ptr<ProductA2> ptr = std::make_shared<ProductA2>();
//将子类指针转化为父类指针
return dynamic_cast<AbstractProductA*>(ptr.get());
}
AbstractProductB* ConcreteFactory2::CreateProductB()
{
//创建具体产品子类B2的智能指针，防止内存被消除
std::shared_ptr<ProductB2> ptr = std::make_shared<ProductB2>();
//将子类指针转化为父类指针
return dynamic_cast<AbstractProductB*>(ptr.get());
}
5.main.cpp
代码如下（示例）：
#include "AbstractFactory.h"
#include "Product.h"
int main(int argc, char* argv[])
{
//定义抽象工厂类1
AbstractFactory* cf1 = new ConcreteFactory1();
//生产产品类A1
cf1->CreateProductA();
//生产产品类B1
cf1->CreateProductB();
//定义抽象工厂类2
AbstractFactory* cf2 = new ConcreteFactory2();
//生产产品类A2
cf2->CreateProductA();
//生产产品类A2
cf2->CreateProductB();
return 0;
}
三、运行结果
AbstactFactory 模式码运行结果如下:
总结
AbstractFactory 模式的实现代码很简单，在测试程序中可以看到，当我们要创建一组对象（ProductA1，ProductA2）的时候我们只用维护一个创建对象（ConcreteFactory1），大大简化了维护的成本和工作。
AbstractFactory 模式和 Factory 模式的区别是一个容易引起困惑的地方。实际上，AbstractFactory 模式是为创建一组（有多类）相关或依赖的对象提供创建接口，而 Factory 模式为一类对象提供创建接口或延迟对象的创建到子类中实现。
本文参考《设计模式精解－GoF 23 种设计模式解析附 C++实现源码》，对内容进行整理，方便大家学习。如想学习详细内容，请参考此书。
