抽象工厂模式 AbstractFactory

#include "stdafx.h"
#include <iostream>
#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>
#include <string>

using namespace boost;

enum Level1_Monster_Class{Level1_A = 1000,Level1_B}type_monster1;
enum Level2_Monster_Class{Level2_C = 2000,Level2_D}type_monster2;

//抽象工厂是用来创建在需要创建很多
//产品(Object),产品的种类不同时，
//可以用抽象工厂进行分类创建

//这里以创建不同游戏等级的怪物为例解释抽象工厂
//要求创建1，2，3,...等级的怪物
//第一关只能创建1等级的怪物，第n关创建n等级的怪物
//而且每一关等级怪物的种类个有多种
//这里用对应的某个个具体工厂创建某个工厂的怪物
//在对应的某个具体工厂的里创建该等级具体种类的怪物


//Monster等的定义必须在工厂类之前
//否则会编译报错,会报指针无法转换的错误
//虽然指针之间是继承关系,简单的类的前置
//声明可以解决部分问题,但是用到前置什么的类
//的过多特性时，前置什么就不行,
//这是就必须先定义这个类，不能用前置什么的方式

//怪物基类
class Monster
{
public:
	//必须写这个,虽然用不到，如果不写，编译会报错
	//因为已经写了一个构造函数，编译器就不会生成默认构造函数了
	Monster(){}
	Monster(const std::string & strName)
	{
		_m_strName = strName;
	}
	virtual ~Monster(){}

	CC_SYNTHESIZE_READONLY(std::string,_m_strName,MonsterName);
	void printName()
	{
		std::cout << "Monster Name:" << _m_strName << std::endl;
	}
};

class Monster_A : public Monster
{
public:
	Monster_A(){}
	Monster_A(const std::string & strName) : Monster(strName){}
	virtual ~Monster_A(){}
};
class Monster_B : public Monster
{
public:
	Monster_B(const std::string & strName) : Monster(strName){}

};
class Monster_C : public Monster
{
public:
	Monster_C(const std::string & strName) : Monster(strName){}

};
class Monster_D : public Monster
{
public:
	Monster_D(const std::string & strName) : Monster(strName){}

};

//抽象工厂类
class AbstractFactory
{
public:
	std::string getLevel()
	{
		return _m_strLevel;
	}
protected:
	//必须写这个,虽然用不到，如果不写，编译会报错
	//因为已经写了一个构造函数，编译器就不会生成默认构造函数了
	AbstractFactory(){}
	AbstractFactory(const std::string & str) : _m_strLevel(str){}
	virtual ~AbstractFactory(){}
public:
	virtual shared_ptr<Monster> createMonster(int type) = 0;
protected:
	std::string _m_strLevel;
};

//具体工厂类1，用于创建等级1的怪物
class ConcreteFactory1 : public AbstractFactory
{
public:
	ConcreteFactory1(){}
	ConcreteFactory1(const std::string& strLevel) : AbstractFactory(strLevel){}
	virtual ~ConcreteFactory1(){}

	shared_ptr<Monster> createMonster(int type)
	{
		switch(type)
		{
		case Level1_A:
			return boost::make_shared<Monster_A>("AAA");
 			break;
		case Level1_B:
			return boost::make_shared<Monster_A>("BBB");
			break;
		default:
			break;
		}
		return NULL;
	}
};

//具体工厂类2，用于创建等级1的怪物
class ConcreteFactory2 : public AbstractFactory
{
public:
	ConcreteFactory2(){}
	ConcreteFactory2(const std::string & strLevel) : AbstractFactory(strLevel){}
	virtual ~ConcreteFactory2(){}
	shared_ptr<Monster> createMonster(int type)
	{
		switch(type)
		{
		case Level2_C:
			return make_shared<Monster_C>("CCC");
			break;
		case Level2_D:
			return make_shared<Monster_D>("DDD");
			break;
		default:
			break;
		}
		return NULL;
	}
};

void testAbstarctFactory()
{
	shared_ptr<ConcreteFactory1> level1Factory = make_shared<ConcreteFactory1>();
	auto level2Factory = make_shared<ConcreteFactory2>();
	auto m1 = level1Factory->createMonster(Level1_A);
	auto m2 = level1Factory->createMonster(Level1_B);
	m1->printName();
	m2->printName();
	auto m3 = level2Factory->createMonster(Level2_C);
	auto m4 = level2Factory->createMonster(Level2_D);
	m3->printName();
	m4->printName();
}