#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();
}
转载请注明原文地址: https://ju.6miu.com/read-676660.html
