C++设计模式之抽象工厂模式(改编自C++设计模式)

AbstactFactory  模式

Question:

假设我们要开发一款游戏，当然为了吸引更多的人玩，游戏难度不能太大（让大家都没有信心了，估计游戏也就没有前途

了），但是也不能太简单（没有挑战性也不符合玩家的心理）。于是我们就可以采用这样一种处理策略：为游戏设立等级，初

级、中级、高级甚至有BT 级。假设也是过关的游戏，每个关卡都有一些怪物（monster）守着，玩家要把这些怪物干掉才可以

过关。作为开发者，我们就不得不创建怪物的类，然后初级怪物、中级怪物等都继承自怪物类（当然不同种类的则需要另创建

类，

但是模式相同）。在每个关卡，我们都要创建怪物的实例，例如初级就创建初级怪物（有很多种类）、中级创建中级怪物等。

可以想象在这个系统中，将会有成千上万的怪物实例要创建，问题是还要保证创建的时候不会出错：初级不能创建 BT 级的怪

物（玩家就郁闷了，玩家一郁闷，游戏也就挂挂了），反之也不可以。

Answer:

AbstractFactory 模式就是用来解决这类问题的：要创建一组相关或者相互依赖的对象。

GOOD：

定义了一个创建一系列相关或相互依赖的接口，而无需指定它们的具体类。

Pic:

Code:

<pre name="code" class="cpp">#include <string>
#include <iostream>
#include <vector>
using namespace std;

//用户抽象接口
class IUser
{
public:
	virtual void GetUser() = 0;
	virtual void InsertUser() = 0;
};

//部门抽象接口
class IDepartment
{
public:
	virtual void GetDepartment() = 0;
	virtual void InsertDepartment() = 0;
};

//ACCESS用户
class CAccessUser : public IUser
{
public:
	virtual void GetUser()
	{
		cout << "Access GetUser" << endl;
	}
	virtual void InsertUser()
	{
		cout << "Access InsertUser" << endl;
	}
};

//ACCESS部门
class CAccessDepartment : public IDepartment
{
public:
	virtual void GetDepartment()
	{
		cout << "Access GetDepartment" << endl;
	}
	virtual void InsertDepartment()
	{
		cout << "Access InsertDepartment" << endl;
	}
};

//SQL用户
class CSqlUser : public IUser
{
public:
	virtual void GetUser()
	{
		cout << "Sql User" << endl;
	}
	virtual void InsertUser()
	{
		cout << "Sql User" << endl;
	}
};

//SQL部门类
class CSqlDepartment : public IDepartment
{
public:
	virtual void GetDepartment()
	{
		cout << "sql getDepartment" << endl;
	}
	virtual void InsertDepartment()
	{
		cout << "sql insertdepartment" << endl;
	}
};

//抽象工厂
class IFactory
{
public:
	virtual IUser* CreateUser() = 0;
	virtual IDepartment* CreateDepartment() = 0;
};

//ACCESS工厂
class AccessFactory : public IFactory
{
public:
	virtual IUser* CreateUser()
	{
		return new  CAccessUser();
	}
	virtual IDepartment* CreateDepartment()
	{
		return new CAccessDepartment();
	}
};

//SQL工厂
class SqlFactory : public IFactory
{
public:
	virtual IUser* CreateUser()
	{
		return new  CSqlUser();
	}
	virtual IDepartment* CreateDepartment()
	{
		return new CSqlDepartment();
	}
};

//客户端：
int main()
{
	IFactory* sfactory = new SqlFactory();
	IUser* suser = sfactory->CreateUser();
	IDepartment* sdepart = sfactory->CreateDepartment();
	suser->GetUser();
	sdepart->GetDepartment();
	
	IFactory * afactory = new AccessFactory();
	IUser* auser = afactory->CreateUser();
	IDepartment* adepart = afactory->CreateDepartment();
	auser->GetUser();
	adepart->GetDepartment();

	cin.get();
	return 0;
}

Comment:

AbstractFactory 模式是为创建 一组 （有多类）相关或依赖的对象提供创建接口，而 Factory 模式正如我在相应的

文档中分析的是为 一类对象提供创建接口或延迟对象的创建到子类中实现。并且可以看到，AbstractFactory 模式通常

都是使用 Factory 模式实现（ConcreteFactory）。