//---------------------------15/04/07----------------------------
//prototype 原型模式－－对象创建型模式
/*
1:意图：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
2:动机：
3:适用性：
1>当一个系统应该独立于它的产品创建、构成和表示时
2>当要实例化的类是在运行时刻制定时，例如通过动态装载
3>为了避免创建一个与产品类层次平行的工厂类层次时
4>当一个类的实例只能有几个不同状态组合中的一种时
4:结构：
Client:
prototype------------------------------->Prototype:
Operation() Clone()
{ p = prototype->Clone()} |
| |
ConcretePrototype1: ConcretePrototype2:
Clone() Clone()
{return copy of self} {return copy of self}
5:参与者：
1>Prototype：声明一个克隆自身的接口。
2>ConcretePrototype：实现一个克隆自身的操作。
3>Client：让一个原型克隆自身从而创建一个新的对象。
6:协作：客户请求一个原型克隆自身。
7:效果：
1>优点：
1)运行时刻可以增加和删除产品，更加灵活。
2)改变值以指定新对象。
可以为对象指定新值来实例化新的对象，
这种设计可以极大减少系统所需的类的数目。
3)改变结构以制定新对象。
针对一些由部件和子部件来创建的对象，
反映了Composite模式(改变child的多少或类型等)以及Decorator模式(暂时不知道<未知标记>)
这里Clone需要实现为深拷贝，不然child都是一样的这个结构改变一下，别的结构就跟着改变了。
4)减少子类的构造。相比较于Factory Method，不需要创建一个creator类层次，
需要一个对象时只用克隆一个就行，而不是靠creator类创建。
5)用类动态配置应用(不懂<未知标记>)
2>缺陷：
每一个子类都必须实现Clone操作。当类已经存在，新增Clone操作会很难。当内部包括一些不
支持拷贝(不支持拷贝，就无法调用拷贝构造函数实现Clone操作)或有循环引用(要实现深拷贝，就
要不断重复了)的对象时，实现克隆也会很困难。
8:实现：
1>使用一个原型管理器。
当一个系统中原型数目不固定时(也就是，客户会动态创建和销毁)，要保持一个可
用原型的注册表。客户可以通过注册表来存储和检索原型。
2>实现克隆操作。对一些复杂的对象进行深拷贝。
3>初始化克隆对象
如果原型的类已经定义好了设置关键状态的操作就不用提供initialize操作，
否则，就必须提供一个initialize操作来初始化参数。
9:代码示例： */
//原型工厂
class MazePrototypeFactory :
public MazeFactory
{
public:
MazePrototypeFactory(Maze*, Wall*, Room*, Door*);
virtual Maze* MakeMaze()
const;
virtual Room* MakeRoom(int)
const;
virtual Wall* MakeWall()
const;
virtual Door* MakeDoor(Room*, Room*)
const;
private:
Maze* _prototypeMaze;
Room* _prototypeRoom;
Wall* _prototypeWall;
Door* _prototypeDoor;
};
//初始化每一个原型
MazePrototypeFactory::MazePrototypeFactory
(Maze* m, Wall* w, Room* r, Door* d)
{
_prototypeMaze = m;
_prototypeRoom = r;
_prototypeWall = w;
_prototypeDoor = d;
}
//实现基类的virtual方法，内部调用Clone实现
Wall* MazePrototypeFactory::MakeWall()
const
{
return _prototypeWall->Clone();
}
//效用Clone后还要初始化克隆对象
Door* MazePrototypeFactory::MakeDoor(Room* r1, Room* r2)
const
{
Door* door = _prototypeDoor->Clone();
door->Initialize(r1, r2);
return door;
}
//使用方法
MakeGame game;
MazePrototypeFactory simpleMazeFactor(new Maze,
new Wall, new Room,
new Door);
maze* maze = game.CreateMaze(simpleMazeFactor);
/////////
//下面要换其中的部件，来实现新的“原型类”，要作为部件，必须实现clone操作
MazePrototypeFactory bombedMazeFactory(
new Maze,
new BombedWall, new RoomWithABomb,
new Door);
//Door中有两个数据可以设置或者说需要设置，所以要提供一个initilize函数
class Door :
public MapSite
{
public:
Door();
Door(const Door&);
virtual void Initialize(Room*, Room*);
virtual Door* Clone()
const;
virtual void Enter();
Room* OtherSideFrom(Room*);
private:
Room* _room1;
Room* _room2;
};
Door::Door (const Door& other)
{
_room1 = other._room1;
_room2 = other._room2;
}
void Door::Initialize(Room* r1, Room* r2)
{
_room1 = r1;
_room2 = r2;
}
Door* Door::Clone()
const
{
return new Door(*this);
}
//这里应该也有一个initialize函数才对。用来设置是否有炸弹
class BombedWall :
public wall
{
public:
BombedWall();
BombedWall(const BombedWall&);
virtual Wall* Clone()
const;
bool HasBomb();
private:
bool _bomb;
};
BombedWall::BombedWall(const BombedWall& other) : Wall(other)
{
_bomb = other._bomb;
}
Wall* BombedWall::Clone()
const
{
return new BombedWall(*this);
}
//这样子每次用的时候都要重新使用部件创建一个“类”。
//可以用一个map把“类”存起来
map<string,MazePrototypeFactory> MazeTable;
MazeTable.insert(make_pair("bombedMazeFactory",bombedMazeFactory));
//要用的时候取出：
game.CreateMaze(map["bombedMazeFactory"]);
//可以把直接map封装到game中，然后致用传入一个字符串就行。
//不过这样需要提供一个注册函数和销毁函数，来对“类”进行注册和销毁。
//下面是ios设计模式解析版本的：
/*
1:在以下情形，会考虑使用原型模式：
1>需要创建的对象应独立于其类型与创建方式。(太抽象<未知标记>)
2>要实例化的类是在运行时决定的。
3>不想要与产品层次相对应的工厂层次。
4>不同类的实例间的差异仅仅是状态的若干组合。因此复制响应数量的原型比手工实例化更加方便。
5>类不容易创建，比如每个组件可以把其他组件作为子节点的组合对象。复制已有的组合
对象，并对副本进行修改会更加容易。
2:考虑使用原型模式的情景：
1>有很多相关的类，其行为略不同，而且主要差别在于内部属性，比如名称，图像等；
2>徐傲使用组合对象作为其他东西的基础，比如，使用组合对象作为组件来构建另一个组合对象。
*/