设计模式学习-原型模式

游戏中我们需要各种怪物角色，比如幽灵、恶魔、术士，我们如何设计去生成这几种怪物呢？

第一种，设计这几种怪物类，添加一个怪物生成器

简单示例

class Monster
{
};

class Ghost : public Monster
{};

class Demon : public Monster
{};

class Sorcerer : public Monster
{};

class Spawner
{
public:
	virtual ~Spawner(){}
	virtual Monster* spawner() = 0;
private:
};

class GhostSpwaner : public Spawner
{
public:
	Monster* spawner() 
	{
		new Ghost;
	}
};

class DemonSpwaner : public Spawner
{
public:
	Monster* spawner()
	{
		new Demon;
	}
};

class SorcererSpwaner : public Spawner
{
public:
	Monster* spawner()
	{
		new Sorcerer;
	}
};

第二种方式（利用原型本身）

class Monster
{
public:
	virtual ~Monster(){}
	virtual Monster* Clone() = 0;
};

class Ghost : public Monster
{
public:
	Monster* Clone()
	{
		new Ghost;
	}
};

class Demon : public Monster
{
public:
	Monster* Clone()
	{
		new Demon;
	}
};

class Sorcerer : public Monster
{
public:
	Monster* Clone()
	{
		new Sorcerer;
	}
};

class Spawner
{
public:
	Spawner(Monster* proto):m_Proto(proto){}
	Monster* spawnMonster()
	{
		return m_Proto->Clone();
	}
private:
	Monster* m_Proto;
};

Spawner* spawner = new Spawner(new Ghost);
Ghost* ghost = spawner->spawnMonster();

第三种方式，不在利用原型实例对象

#include <functional>
class Monster
{
public:
	virtual ~Monster(){}
};

class Ghost : public Monster
{
public:
	static Monster* Clone()
	{
		new Ghost;
	}
};

class Demon : public Monster
{
public:
	static Monster* Clone()
	{
		new Demon;
	}
};

class Sorcerer : public Monster
{
public:
	static Monster* Clone()
	{
		new Sorcerer;
	}
};

typedef std::function<Monster*()> FuncType;
class Spawner
{
public:
	Spawner(FuncType spawn):m_SpawnCallback(spawn) {}
	Monster* spawnMonster()
	{
		return m_SpawnCallback();
	}
private:
	FuncType m_SpawnCallback;
};

Spawner* spawner = new Spawner(Ghost::Clone);
Ghost* ghost = spawner->spawnMonster();

第四种，利用模板直接生成实例

class Monster
{
public:
	virtual ~Monster(){}
private:
};

class Ghost : public Monster
{
public:

};

class Demon : public Monster
{
public:

};

class Sorcerer : public Monster
{
public:

};

class Spwaner
{
public:
	virtual ~Spwaner(){}
	virtual Monster* spwanMonster() = 0;
private:
};

template <typename T>
class SpwanerMonster : public Spwaner
{
public:
	Monster* spwanMonster()
	{
		return new T();
	}
private:
};

Monster* ghost = new SpwanerMonster<Ghost>()->spwanMonster();

第二种是原型模式，一般在普通程序种是不会使用原型模式的，它主要是在语言设计上，比如java 或者 python object 对象就是原型，所有类型对象都是从object克隆而来的。