设计模式---创建类型---原型

1、意图
用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
2、适用性
当一个系统应该独立于它的产品创建、构成和表示时，要使用Prototype模式；以及
1）当要实例化的类是在运行时刻指定时，例如，通过动态装载；或者
2）为了避免创建一个与产品类层次平行的工厂类层次时；或者
3）当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。

3、C++实例

// Test.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include <Windows.h>
#include <list>
#include <string>

using namespace std;

enum Direction
{
	North = 0,
	South,
	East,
	West
};


class MapSite
{

public:
	virtual void Enter()=0;
};


class Room: public MapSite
{

public:

	Room( int roomNo )
	{
		_roomNumber = roomNo;
		
	}

	Room( const Room &r )
	{
		_roomNumber = r._roomNumber;
	}


	MapSite* GetSide( Direction d ) const
	{
		return _sides[d];
	}

	void SetSide( Direction d, MapSite *m )
	{
		_sides[d] = m;
	}

	virtual void Enter()
	{

	}

	virtual Room* Clone( ) const
	{
		return new Room( *this );
	}

private:

	MapSite *_sides[4];

	int _roomNumber;
};


class Wall: public MapSite
{
	
public:

	Wall()
	{

	}

	Wall( const Wall &w )
	{
		// ....
	}

	virtual void Enter()
	{

	}

	virtual Wall* Clone( ) const
	{
		return new Wall( *this );
	}
};


class Door:public MapSite
{

public:
	Door()
	{

	}

	Door( const Door& other )
	{
		_room1 = other._room1;
		_room2 = other._room2;
	}

	void Initialize( Room* r1, Room* r2 )
	{
		_room1 = r1;
		_room2 = r2;
	}

	Door* clone() const
	{
		return new Door( *this );
	}

	virtual void Enter()
	{

	}

	Room* OtherSideFrom( Room *r )
	{
		return NULL;
	}

private:

	Room* _room1;

	Room* _room2;

};

class Maze
{

public:
	
	Maze()
	{

	}

	void AddRoom( Room *r )
	{
		_room = r;
	}

	Room* RoomNo( int no ) const
	{
		return new Room( no );
	}

private:

	Room *_room;
};


class MazeFactory
{

public:

	MazeFactory()
	{

	}

	virtual Maze* MakeMaze() const
	{
		return new Maze;
	}

	virtual Wall* MakeWall() const
	{
		return new Wall;
	}

	virtual Room* MakeRoom( int n ) const
	{
		return new Room( n );
	}

	virtual Door* MakeDoor( Room *r1, Room *r2) const
	{
		return new Door;
	}
};

class MazePrototypeFactory: public MazeFactory
{

public:

	MazePrototypeFactory( Maze *m, Wall *w, Room *r, Door *d )
	{
		_prototypeMaze = m;
		_prototypeRoom = r;
		_prototypeWall = w;
		_prototypeDoor = d;
	}


	virtual Wall* MakeWall() const
	{
		return _prototypeWall->Clone();
	}

	virtual Room* MakeRoom( int n ) const
	{
		return _prototypeRoom->Clone();
	}

	virtual Door* MakeDoor( Room *r1, Room *r2) const
	{
		Door *door = _prototypeDoor->clone();
		door->Initialize( r1, r2 );
		return door;
	}

private:

	Maze *_prototypeMaze;

	Room *_prototypeRoom;

	Wall *_prototypeWall;

	Door *_prototypeDoor;
};

class MazeGame
{

public:

	MazeGame(  )
	{

	}


	Maze* CreateMaze( )
	{
		Maze* aMaze = new Maze;
		MazePrototypeFactory *prototypeFactory = new MazePrototypeFactory( aMaze, new Wall , new Room(111) , new Door  );

		

		Room *r1 = prototypeFactory->MakeRoom( 1 );
		Room *r2 = prototypeFactory->MakeRoom( 2 );

		Door *theDoor = prototypeFactory->MakeDoor( r1, r2 );

		aMaze->AddRoom( r1 );
		aMaze->AddRoom( r2 );

		r1->SetSide( North, prototypeFactory->MakeWall() );
		r1->SetSide( East, theDoor );
		r1->SetSide( South, prototypeFactory->MakeWall() );
		r1->SetSide( West, prototypeFactory->MakeWall() );

		r2->SetSide( North, prototypeFactory->MakeWall() );
		r2->SetSide( East, prototypeFactory->MakeWall() );
		r2->SetSide( South, prototypeFactory->MakeWall() );
		r2->SetSide( West, theDoor );

		return aMaze;
	}
};


int _tmain(int argc, _TCHAR* argv[])
{

	MazeGame *game = new MazeGame;
	Maze* bommaze = game->CreateMaze();
	
	return 0;
}