假装异步加载中...
29 Sep 2013

设计模式 - 抽象工厂模式

问题

假设我们要开发一款游戏，当然为了吸引更多的人玩，游戏难度不能太大（让大家都没有信心了，估计游戏也就没有前途了），但是也不能太简单（没有挑战性也不符合玩家的心理）。于是我们就可以采用这样一种处理策略：为游戏设立等级，初级、中级、高级甚至有BT 级。假设也是过关的游戏，每个关卡都有一些怪物（monster）守着，玩家要把这些怪物干掉才可以过关。

作为开发者，我们就不得不创建怪物的类，然后初级怪物、中级怪物等都继承自怪物类（当然不同种类的则需要另创建类，但是模式相同）。在每个关卡，我们都要创建怪物的实例，例如初级就创建初级怪物（有很多种类）、中级创建中级怪物等。可以想象在这个系统中，将会有成千上万的怪物实例要创建，问题是还要保证创建的时候不会出错：初级不能创建 BT 级的怪物（玩家就郁闷了，玩家一郁闷，游戏也就挂挂了），反之也不可以。

模式选择

AbstractFactory模式就是用来解决这类问题的：要创建一组相关或者相互依赖的对象。 Abstract Factory 模式关键就是将这一组对象的创建封装到一个用于创建对象的类（ConcreteFactory）中，维护这样一个创建类总比维护 n 多相关对象的创建过程要简单的多。

实现

// IPhone.h
#ifndef __IPHONE_H__
#define __IPHONE_H__

class IPhone
{
public:
	IPhone(){};
	virtual ~IPhone(){};
	virtual void showName() = 0;
};

#endif

// Phone.h
#ifndef __PHONE_H__
#define __PHONE_H__
#include "IPhone.h"

class CMX1Phone:public IPhone
{
public:
	CMX1Phone();
	virtual ~CMX1Phone();
	virtual void showName();
};

class CMX2Phone:public IPhone
{
public:
	CMX2Phone();
	virtual ~CMX2Phone();
	virtual void showName();
};

class CMX3Phone:public IPhone
{
public:
	CMX3Phone();
	virtual ~CMX3Phone();
	virtual void showName();
};

class CMI1Phone:public IPhone
{
public:
	CMI1Phone();
	virtual ~CMI1Phone();
	virtual void showName();
};

class CMI2Phone:public IPhone
{
public:
	CMI2Phone();
	virtual ~CMI2Phone();
	virtual void showName();
};

#endif

// Phone.cpp
#include "Phone.h"
#include <iostream>

CMX1Phone::CMX1Phone()
{
}

CMX1Phone::~CMX1Phone()
{
}

void CMX1Phone::showName()
{
	std::cout << "I am mx1 of meizu!\n";
}

CMX2Phone::CMX2Phone()
{
}

CMX2Phone::~CMX2Phone()
{
}

void CMX2Phone::showName()
{
	std::cout << "I am mx2 of meizu!\n";
}

CMX3Phone::CMX3Phone()
{
}

CMX3Phone::~CMX3Phone()
{
}

void CMX3Phone::showName()
{
	std::cout << "I am mx3 of meizu!\n";
}

CMI1Phone::CMI1Phone()
{
}

CMI1Phone::~CMI1Phone()
{
}

void CMI1Phone::showName()
{
	std::cout << "I am mi1 of xiaomi!\n";
}

CMI2Phone::CMI2Phone()
{
}

CMI2Phone::~CMI2Phone()
{
}

void CMI2Phone::showName()
{
	std::cout << "I am mi2 of xiaomi!\n";
}

// IBattery.h
#ifndef __IBATTERY_H__
#define __IBATTERY_H__

class IBattery
{
public:
	IBattery(){};
	virtual ~IBattery(){};
	virtual void showName() = 0;
};

#endif

// Battery.h
#ifndef __BATTERY_H__
#define __BATTERY_H__
#include "IBattery.h"

class CMX1Battery:public IBattery
{
public:
	CMX1Battery();
	virtual ~CMX1Battery();
	virtual void showName();
};

class CMX2Battery:public IBattery
{
public:
	CMX2Battery();
	virtual ~CMX2Battery();
	virtual void showName();
};

class CMX3Battery:public IBattery
{
public:
	CMX3Battery();
	virtual ~CMX3Battery();
	virtual void showName();
};

class CMI1Battery:public IBattery
{
public:
	CMI1Battery();
	virtual ~CMI1Battery();
	virtual void showName();
};

class CMI2Battery:public IBattery
{
public:
	CMI2Battery();
	virtual ~CMI2Battery();
	virtual void showName();
};

#endif

// Battery.cpp
#include "Battery.h"
#include <iostream>

CMX1Battery::CMX1Battery()
{
}

CMX1Battery::~CMX1Battery()
{
}

void CMX1Battery::showName()
{
	std::cout << "I am mx1's battery of meizu!\n";
}

CMX2Battery::CMX2Battery()
{
}

CMX2Battery::~CMX2Battery()
{
}

void CMX2Battery::showName()
{
	std::cout << "I am mx2's battery of meizu!\n";
}

CMX3Battery::CMX3Battery()
{
}

CMX3Battery::~CMX3Battery()
{
}

void CMX3Battery::showName()
{
	std::cout << "I am mx3's battery of meizu!\n";
}

CMI1Battery::CMI1Battery()
{
}

CMI1Battery::~CMI1Battery()
{
}

void CMI1Battery::showName()
{
	std::cout << "I am mi1's battery of xiaomi!\n";
}

CMI2Battery::CMI2Battery()
{
}

CMI2Battery::~CMI2Battery()
{
}

void CMI2Battery::showName()
{
	std::cout << "I am mi2's battery of xiaomi!\n";
}

// IFactory.h
#ifndef __IFACTORY_H__
#define __IFACTORY_H__
#include "IPhone.h"
#include "IBattery.h"
#include <string>

class IFactory
{
public:
	IFactory(){};
	virtual ~IFactory(){};
	virtual IPhone* createPhone(std::string strName) = 0;
	virtual IBattery* createBattery(std::string strName) = 0;
};

#endif

// BatteryFactory.h
#ifndef __BATTERY_FACTORY_H__
#define __BATTERY_FACTORY_H__
#include "IFactory.h"
#include "IPhone.h"
#include "IBattery.h"

class CMXFactory:public IFactory
{
public:
	CMXFactory();
	virtual ~CMXFactory();
	virtual IPhone* createPhone(std::string strName);
	virtual IBattery* createBattery(std::string strName);
};

class CMIFactory:public IFactory
{
public:
	CMIFactory();
	virtual ~CMIFactory();
	virtual IPhone* createPhone(std::string strName);
	virtual IBattery* createBattery(std::string strName);
};

#endif

// BatteryFactory.cpp
#include "Factory.h"
#include "Phone.h"
#include "Battery.h"

CMXFactory::CMXFactory()
{
}

CMXFactory::~CMXFactory()
{
}

IPhone* CMXFactory::createPhone(std::string strName)
{
	IPhone* pPhone = NULL;
	if (strName == "mx1")
	{
		pPhone = new CMX1Phone();
	}
	else if (strName == "mx2")
	{
		pPhone = new CMX2Phone();
	}
	else if (strName == "mx3")
	{
		pPhone = new CMX3Phone();
	}

	if (pPhone != NULL)
	{
		pPhone->showName();
	}

	return pPhone;
}

IBattery* CMXFactory::createBattery(std::string strName)
{
	IBattery* pBattery = NULL;
	if (strName == "mx1")
	{
		pBattery = new CMX1Battery();
	}
	else if (strName == "mx2")
	{
		pBattery = new CMX2Battery();
	}
	else if (strName == "mx3")
	{
		pBattery = new CMX3Battery();
	}

	if (pBattery != NULL)
	{
		pBattery->showName();
	}

	return pBattery;
}

CMIFactory::CMIFactory()
{
}

CMIFactory::~CMIFactory()
{
}

IPhone* CMIFactory::createPhone(std::string strName)
{
	IPhone* pPhone = NULL;
	if (strName == "mi1")
	{
		pPhone = new CMI1Phone();
	}
	else if (strName == "mi2")
	{
		pPhone = new CMI2Phone();
	}

	if (pPhone != NULL)
	{
		pPhone->showName();
	}

	return pPhone;
}

IBattery* CMIFactory::createBattery(std::string strName)
{
	IBattery* pBattery = NULL;
	if (strName == "mi1")
	{
		pBattery = new CMI1Battery();
	}
	else if (strName == "mi2")
	{
		pBattery = new CMI2Battery();
	}

	if (pBattery != NULL)
	{
		pBattery->showName();
	}

	return pBattery;
}

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

int main()
{
	std::string strName[2][4] = {"mx1","mx2","mx3","mx4","mi1","mi2","mi3","mi4"};
	IFactory* pFactory[2] = {new CMXFactory(),new CMIFactory()};
	for (int n = 0; n < 2; ++n)
	{
		for (int i = 0; i < 4; ++i)
		{
			IPhone* pPhone = pFactory[n]->createPhone(strName[n][i]);
			if (pPhone == NULL)
			{
				std::cout << "not exist phone of " << strName[n][i] << "!\n";
			}
			delete pPhone;

			IBattery* pBattery = pFactory[n]->createBattery(strName[n][i]);
			if (pBattery == NULL)
			{
				std::cout << "not exist battery of " << strName[n][i] << "!\n";
			}
			delete pBattery;
		}
		delete pFactory[n];
		pFactory[n] = NULL;
	}
	return 0;
}
上一篇： 设计模式 - 工厂模式
上一篇： 设计模式 - 单例模式