设计模式---创建类型---生成器

1、意图

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

2、适用性
在以下情况使用Builderr模式
1）当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
2）当构造过程必须允许被构造的对象有不同的表示时。

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;
		
	}


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

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

	virtual void Enter()
	{

	}

private:

	MapSite *_sides[4];

	int _roomNumber;
};


class Wall: public MapSite
{
	
public:

	Wall()
	{

	}

	virtual void Enter()
	{

	}
};


class Door:public MapSite
{

public:

	Door( Room* r1 = NULL, Room* r2 = NULL )
	{
		_room1 = r1;
		_room2 = r2;
	}

	virtual void Enter()
	{

	}

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

private:

	Room* _room1;

	Room* _room2;

	bool _isOpen;
};

class Maze
{

public:
	
	Maze()
	{

	}

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

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

private:

	Room *_room;
};

class MazeBuilder
{

public:

	virtual void BuildMaze()
	{

	}

	virtual void BuildRoom( int room )
	{

	}
	
	virtual void BuildDoor( int roomFrom, int roomTo )
	{

	}

	virtual Maze* GetMaze()
	{
		return NULL;
	}

protected:

	MazeBuilder()
	{

	}
};


class MazeGame
{

public:

	MazeGame(  )
	{

	}

	Maze* CreateMaze( MazeBuilder &builder )
	{
		builder.BuildMaze();

		builder.BuildRoom( 1 );
		builder.BuildRoom( 2 );
		builder.BuildDoor( 1, 2 );

		return builder.GetMaze();
	}

	Maze* CreateComplexMaze( MazeBuilder &builder )
	{
		builder.BuildMaze();

		builder.BuildRoom( 1 );
		// ...
		builder.BuildRoom( 10000 );
		builder.BuildDoor( 1, 10000 );

		return builder.GetMaze();
	}
};

class StandardMazeBuilder: public MazeBuilder
{

public:

	StandardMazeBuilder()
	{
		_currentMaze = NULL;
	}

	void BuildMaze()
	{
		_currentMaze = new Maze;
	}

	Maze* GetMaze()
	{
		return _currentMaze;
	}

	void BuildRoom( int n )
	{
		if ( !_currentMaze->RoomNo( n ))
		{
			Room* room = new Room( n );
			_currentMaze->AddRoom( room );


			room->SetSide( North , new Wall );
			room->SetSide( South , new Wall );
			room->SetSide( East , new Wall );
			room->SetSide( West , new Wall );
		}
	}

	void BuildDoor( int n1, int n2 )
	{
		Room* r1 = _currentMaze->RoomNo( n1 );
		Room* r2 = _currentMaze->RoomNo( n2 );
		Door* d = new Door( r1, r2 );

		r1->SetSide( CommonWall( r1, r2 ), d );
		r2->SetSide( CommonWall( r1, r2 ), d );
	}

private:

	Direction CommonWall( Room* r1, Room* r2 )
	{
		// return common wall ( to do ) 
		return South;
	}

	Maze* _currentMaze;
};

class CountingMazeBuilder: public MazeBuilder
{

public:

	CountingMazeBuilder()
	{
		_rooms = _doors = 0;
	}

	void BuildRoom( int )
	{
		_rooms++;
	}

	void BuildDoor( int , int )
	{
		_doors++;
	}

	void GetCounts( int &rooms, int &doors ) const
	{
		rooms = _rooms;

		doors = _doors;
	}
private:

	int _doors;

	int _rooms;
};


int _tmain(int argc, _TCHAR* argv[])
{
	Maze* maze ;
	MazeGame game;
	StandardMazeBuilder builder;

	game.CreateMaze( builder );
	maze = builder.GetMaze();

	int rooms, doors;
	CountingMazeBuilder countingbuilder;
	game.CreateMaze( countingbuilder );
	countingbuilder.GetCounts( rooms, doors );
	cout<<"The maze has "<< rooms<<" room and "<<doors<<" doors"<<endl;
	return 0;
}