基于创建型模式的“迷宫”构造

本文在GOF《设计模式》一书“创建型模式”一章的例子和模式的基础上，将各个创建型模式有机的结合在一起。实现了“迷宫”构造过程的封装，增强了构造不同迷宫的可扩展性。

 

创建型模式：

抽象工厂

工厂方法

生成器

原型

单件

 

其中，抽象工厂是由工厂方法组成的，是一组相互关联的工厂方法的集合。

 

“迷宫”构造类图：

 

 

 

 

 

从类图中可以看出各个模式直接的关系，同时为了显示构造好的迷宫图案，还使用了“策略模式”用于画出迷宫（图中的MazeDrawer类层次）。

 

以下是各个模块的C++实现：

1. #ifndef _PART_H_
2. #define _PART_H_
4. //Part.h
6. enum Direction
7. {   
8.     East,
9.     South,
10.     West,
11.     North   
12. };
14. class MapSite
15. {
16. public:
17.     virtual void Enter() = 0;
18.     virtual char* GetInfo() = 0;
19. };
21. class Room:public MapSite
22. {
23. public:
24.     Room(int roomNo)
25.     {
26.         _roomNo = roomNo;
27.         for(int i=0; i<4; ++i)
28.             _sides[i] = 0;
29.     }
30.     
31.     MapSite* GetSide(Direction d) const
32.     {
33.         return _sides[d];
34.     }
36.     void SetSide(Direction d, MapSite* ms)
37.     {
38.         if(_sides[d] != 0)
39.             delete _sides[d];
41.         _sides[d] = ms;
42.     }
44.     virtual void Enter()
45.     {
46.     
47.     }
49.     virtual char* GetInfo()
50.     {
51.         return "Room";
52.     }
54.     int RoomNo() const
55.     {
56.         return _roomNo;
57.     }
59. private:
60.     MapSite* _sides[4];
61.     int _roomNo;
62. };
64. class Wall:public MapSite
65. {
66. public:
67.     Wall()
68.     {
69.     
70.     }
72.     virtual void Enter()
73.     {
74.     
75.     }
76.     virtual char* GetInfo()
77.     {
78.         return "Wall";
79.     }
80. };
82. class Door:public MapSite
83. {
84. public:
85.     Door(Room* r1 = 0, Room* r2 = 0)
86.     {
87.         _room1 = r1;
88.         _room2 = r2;
89.         _isOpen = false;
90.     }
91.     
92.     Room* OtherSideFrom(Room* r)
93.     {
94.         if(r == _room1)
95.             return _room2;
96.         else if(r == _room2)
97.             return _room1;
99.         return 0;
100.     }
102.     virtual void Enter()
103.     {
104.     
105.     }
106.     virtual char* GetInfo()
107.     {
108.         return "Door";
109.     }
110. private:
111.     Room* _room1;
112.     Room* _room2;
113.     bool _isOpen;
114. };
116. class Spell
117. {
118. public:
119.     Spell()
120.     {}
121. };
123. class EnchantedRoom: public Room
124. {
125. public:
126.     EnchantedRoom(int roomNo, Spell* spell):Room(roomNo)
127.     {
128.         _spell = spell;
129.     }
131.     virtual void Enter()
132.     {
133.     
134.     }
135.     virtual char* GetInfo()
136.     {
137.         return "EnchantedRoom";
138.     }
139. private:
140.     Spell* _spell;
141. };
143. class DoorNeedingSpell:public Door
144. {
145. public:
146.     DoorNeedingSpell(Room* r1, Room* r2):Door(r1, r2)
147.     {
148.     
149.     }
151.     virtual void Enter()
152.     {
153.     
154.     }
155.     virtual char* GetInfo()
156.     {
157.         return "DoorNeedingSpell";
158.     }
159. };
162. class RoomWithABomb: public Room
163. {
164. public:
165.     RoomWithABomb(int roomNo):Room(roomNo)
166.     {
167.     
168.     }
170.     virtual void Enter()
171.     {
172.     
173.     }
174.     virtual char* GetInfo()
175.     {
176.         return "RoomWithABomb";
177.     }
178. };
181. class BombedWall:public Wall
182. {
183. public:
184.     BombedWall()
185.     {
186.     
187.     }
189.     virtual void Enter()
190.     {
191.     
192.     }
193.     virtual char* GetInfo()
194.     {
195.         return "BombedWall";
196.     }
197. };
200. class Maze
201. {
202. public:
203.     Maze(int xsize=1, int ysize=1)
204.     {
205.         if(xsize<=0 || ysize<=0)
206.         {
207.             xsize = ysize = 1;
208.         }
210.         _xsize = xsize;
211.         _ysize = ysize;
213.         _roomList = new Room*[_xsize*_ysize];
215.         for(int i=0; i<_xsize*_ysize; ++i)
216.             _roomList[i] = 0;
217.         
218.     }
220.     void AddRoom(Room* r)
221.     {
222.         int rno = r->RoomNo();
223.         
224.         _roomList[rno] = r;
225.     }
227.     Room* RoomNo(int rno) const
228.     {
229.         for(int i=0; i<_xsize*_ysize; ++i)
230.         {
231.             if(_roomList[rno] == 0)
232.                 continue;
234.             if(_roomList[rno]->RoomNo() == rno)
235.                 return _roomList[rno];
236.         }
238.         return 0;
239.     }
240.     
241.     int XSize() const
242.     {
243.         return _xsize;
244.     }
246.     int YSzie() const
247.     {
248.         return _ysize;
249.     }
251.     int Size() const
252.     {
253.         return _xsize*_ysize;
254.     }
256.     ~Maze()
257.     {
258.     
259.     }
260. private:
261.     Room** _roomList;
262.     int _xsize;
263.     int _ysize;
264. };
266. #endif

/////////////////////////////////////////////////////////////////////////////////////////////////////////

1. //PartFactory.h
3. #ifndef _PART_FACTORY_H_
4. #define _PART_FACTORY_H_
7. #include "Part.h"
8. #include <string>
10. class BombedPartFactory;
11. class EnchantedPartFactory;
13. class PartFactory
14. {
15. public:
16.     static PartFactory* Instance();
17.     
18.     static void SetMazeStyle(std::string style)
19.     {
20.         _mazeStyle = style;
21.     }
22. private:
23.     static std::string _mazeStyle;
24.     static PartFactory* _instance;
26. protected:
27.     PartFactory(){}
29. public:
30.     virtual Room* MakeRoom(int rno) const
31.     {
32.         return new Room(rno);
33.     }
34.     
35.     virtual Wall* MakeWall() const
36.     {
37.         return new Wall();
38.     }
40.     virtual Door* MakeDoor(Room* r1, Room* r2) const
41.     {
42.         return new Door(r1, r2);
43.     }
45. };
48. class EnchantedPartFactory:public PartFactory
49. {
50. public:
51.     EnchantedPartFactory(){}
52.     virtual Room* MakeRoom(int rno) const
53.     {
54.         return new EnchantedRoom(rno, CastSpell());
55.     }   
57.     virtual Door* MakeDoor(Room* r1, Room* r2) const
58.     {
59.         return new DoorNeedingSpell(r1, r2);
60.     }
62. protected:
63.     Spell* CastSpell() const
64.     {
65.         return 0;
66.     }
67. };
69. class BombedPartFactory:public PartFactory
70. {
71. public:
72.     BombedPartFactory(){}
73.     virtual Room* MakeRoom(int rno) const
74.     {
75.         return new RoomWithABomb(rno);
76.     }
77.     
78.     virtual Wall* MakeWall() const
79.     {
80.         return new BombedWall();
81.     }
82. };
83. #endif

 

//////////////////////////////////////////////////////////////////////////

1. //PartFactory.cpp
3. #include "PartFactory.h"
6. PartFactory* PartFactory::_instance = 0;
7. std::string PartFactory::_mazeStyle;
9. PartFactory* PartFactory::Instance()
10. {
11.     if(_instance == 0)
12.     {
13.         if(_mazeStyle == "bombed")
14.             _instance = new BombedPartFactory();
15.         else if(_mazeStyle == "enchanted")
16.             _instance = new EnchantedPartFactory();
17.         else
18.             _instance = new PartFactory();
19.     }
21.     return _instance;
22. }

 

////////////////////////////////////////////////////////////////////

1. //MazeBuilder.h
3. #ifndef _MAZE_BUILDER_H_
4. #define _MAZE_BUILDER_H_
6. #include "PartFactory.h"
8. class MazeBuilder
9. {
10. public:
11.     MazeBuilder()
12.     {
13.         BuildMaze();
14.     }
16.     void BuildMaze()
17.     {
18.         _maze = new Maze(8, 8);
19.         _factory = PartFactory::Instance();
20.     }
22.     Maze* GetMaze()
23.     {
24.         return _maze;
25.     }
27.     virtual void BuildRoom(int rno) 
28.     {
29.         //emtpy
30.     }
32.     virtual void BuildDoor(int roomFrom, int roomTo)
33.     {
34.         //emtpy
35.     }
37.     
39. protected:
40.     Direction CommonWall(Room* r1, Room* r2)
41.     {
42.         int xs = _maze->XSize();
43.         Direction dir;
45.         if(r1->RoomNo()+1 == r2->RoomNo())
46.             dir = East;
47.         if(r1->RoomNo()-1 == r2->RoomNo())
48.             dir = West;
49.         if(r1->RoomNo()-xs == r2->RoomNo())
50.             dir = North;
51.         if(r1->RoomNo()+xs == r2->RoomNo())
52.             dir = South;
54.         return dir;
55.     }
56.     
57.     Maze* _maze;
58.     PartFactory* _factory;
59.     
60. };
62. class StdMazeBuilder:public MazeBuilder
63. {
64. public:
65.     StdMazeBuilder(){}
67.     virtual void BuildRoom(int rno) 
68.     {
69.         if(!_maze->RoomNo(rno))
70.         {
71.             Room* r = _factory->MakeRoom(rno);
72.             _maze->AddRoom(r);
74.             r->SetSide(North, _factory->MakeWall());
75.             r->SetSide(South, _factory->MakeWall());
76.             r->SetSide(East, _factory->MakeWall());
77.             r->SetSide(West, _factory->MakeWall());
78.         }
79.     }
81.     virtual void BuildDoor(int roomFrom, int roomTo)
82.     {
83.         Room* r1 = _maze->RoomNo(roomFrom);
84.         Room* r2 = _maze->RoomNo(roomTo);
85.         Door* d = _factory->MakeDoor(r1, r2);
87.         r1->SetSide(CommonWall(r1,r2), d);
88.         r2->SetSide(CommonWall(r2,r1), d);
89.     }
90.     
91. };
93. #endif

 

////////////////////////////////////////////////////////////

1. //MazeDrawer.h
3. #ifndef _MAZE_DRAW_H_
4. #define _MAZE_DRAW_H_
6. #include "Part.h"
7. #include <iostream>
9. class MazeDrawer
10. {
11. public:
12.     virtual void DrawMaze(Maze* maze)
13.     {
14.         for(int i=0; i<maze->Size(); ++i)
15.         {
16.             Room* r = maze->RoomNo(i);
17.             if(r != 0)
18.             {
19.                 std::cout << r->GetInfo() << " " << r->RoomNo() << "#:" << std::endl;
20.                 std::string dir;
21.                 for(int j=0; j<4; ++j)
22.                 {
23.                     switch(j)
24.                     {
25.                     case East:
26.                             dir = "East";
27.                         break;
28.                     case South:
29.                             dir = "South";
30.                         break;
31.                     case West:
32.                             dir = "West";
33.                         break;
34.                     case North:
35.                             dir = "North";
36.                         break;
37.                     }
39.                     std::cout << "    " << dir << ":" << r->GetSide((Direction)j)->GetInfo() << std::endl;
40.                 }
41.             }
42.         }
43.     }
44. };
46. #endif

 

//////////////////////////////////////////////////////////////////

1. //MazeGame.h
3. #ifndef _MAZE_GAME_H_
4. #define _MAZE_GAME_H_
6. #include "MazeBuilder.h"
7. #include "MazeDrawer.h"
9. class MazeGame
10. {
11. public:
12.     MazeGame(MazeDrawer* md=0)
13.     {
14.         _mazeDrawer = md;
15.     }
17.     virtual Maze* CreateMaze(MazeBuilder& mb) = 0;
18.     void DeleteMaze(Maze* maze)
19.     {}
20.     
21.     void DrawMaze(Maze* maze)
22.     {
23.         if(_mazeDrawer != 0)
24.             _mazeDrawer->DrawMaze(maze);
25.     }
26. private:
27.     MazeDrawer* _mazeDrawer;
28. };
30. class Game1:public MazeGame
31. {
32. public:
33.     Game1(MazeDrawer* md):MazeGame(md){}
35.     virtual Maze* CreateMaze(MazeBuilder& mb)
36.     {
37.         for(int i=0; i<24; ++i)
38.             mb.BuildRoom(i);
39.         
40.         mb.BuildDoor(0,1);
41.         mb.BuildDoor(1,2);
42.         mb.BuildDoor(2,10);
43.         mb.BuildDoor(10,11);
44.         mb.BuildDoor(11,12);
45.         mb.BuildDoor(12,20);
46.         mb.BuildDoor(20,21);
47.         mb.BuildDoor(21,22);
48.         mb.BuildDoor(22,14);
49.         mb.BuildDoor(14,15);
50.         return mb.GetMaze();
51.     }
52. };
53. #endif

 

/////////////////////////////////////////////////////////////////

1. // MazeGame.cpp : 定义控制台应用程序的入口点。
2. //
4. #include "stdafx.h"
6. #include "MazeGame.h"
8. int _tmain(int argc, _TCHAR* argv[])
9. {
10.     PartFactory::SetMazeStyle("enchanted");
11.     MazeGame* game = new Game1(new MazeDrawer());
12.     Maze* maze = game->CreateMaze(StdMazeBuilder());
13.     game->DrawMaze(maze);
15.     return 0;
16. }

 

参考文献：GOF《设计模式》

希望通道中人提出意见建议，共同改善完善，共同交流：[e-mail]

 

• 基于创建型模式的“迷宫”构造
• 《GOF设计模式》—创建型模式—Delphi源码示例：未基于模式的迷宫
• 《GOF设计模式》—创建型模式—Delphi源码示例：基于创建型模式的迷宫
• 设计模式中迷宫的实现，用于学习创建型模式
• Js的基于构造函数模式的原型链模式
• 《GOF设计模式》—生成器(Builder)—Delphi源码示例：基于生成器的迷宫
• 《GOF设计模式》—原型(Prototype)—Delphi源码示例：基于原型的迷宫1
• 《GOF设计模式》—原型(Prototype)—Delphi源码示例：基于原型的迷宫2
• 《GOF设计模式》—单件(Singleton)—Delphi源码示例：基于单件的迷宫
• 对象创建的方法二之------构造函数模式
• js 创建对象的三种方式——工厂模式、构造函数模式、原型模式
• 对象的创建：工厂模式/构造函数模式/原型模式 （笔记）
• JavaScript中创建对象的方法：工厂模式,构造函数模式, 原型模式
• JavaScript中常见的几种创建对象的方式：基于对象扩充属性和方法、基于工厂方式创建对象、基于构造函数和基于原型
• 基于栈操作的迷宫问题求解
• 6.基于STL STACK的 迷宫算法
• JS面向对象的几种创建方式：工厂模式、构造函数模式、原型模式、混合模式、动态原型模式
• 《GOF设计模式》—工厂方法(Factory Method)—Delphi源码示例：基于工厂方法的迷宫
• 网络编程错过很多次，而且不容易发现的原因
• 面试问题1:谈谈你对加班的看法
• socket编程
• linux开发 -- 命令行参数解析 getopt
• Java有能力抵挡LAMP的进攻吗？
• 基于创建型模式的“迷宫”构造
• CBR会议论文集和书籍（Proceedings and Books）
• swing 嘴尖介绍 ~~转帖
• MS SQL查询时自动给数据排名：RANK(),DENSE_RANK()
• VB常用代码总结（二）【转】
• VB常用代码总结（一）【转】
• 获取设备句柄的两种方法
• delhpi 数据库中的图像存储和读取
• 一个简单的加密解密算法