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

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

创建型模式：

抽象工厂

工厂方法

生成器

原型

单件

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

“迷宫”构造类图：

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

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

1. #ifndef_PART_H_
2. #define_PART_H_
4. //Part.h
6. enumDirection
7. {
8. East,
9. South,
10. West,
11. North
12. };
14. classMapSite
15. {
16. public:
17. virtualvoidEnter()=0;
18. virtualchar*GetInfo()=0;
19. };
21. classRoom:publicMapSite
22. {
23. public:
24. Room(introomNo)
25. {
26. _roomNo=roomNo;
27. for(inti=0;i<4;++i)
28. _sides[i]=0;
29. }
31. MapSite*GetSide(Directiond)const
32. {
33. return_sides[d];
34. }
36. voidSetSide(Directiond,MapSite*ms)
37. {
38. if(_sides[d]!=0)
39. delete_sides[d];
41. _sides[d]=ms;
42. }
44. virtualvoidEnter()
45. {
47. }
49. virtualchar*GetInfo()
50. {
51. return"Room";
52. }
54. intRoomNo()const
55. {
56. return_roomNo;
57. }
59. private:
60. MapSite*_sides[4];
61. int_roomNo;
62. };
64. classWall:publicMapSite
65. {
66. public:
67. Wall()
68. {
70. }
72. virtualvoidEnter()
73. {
75. }
76. virtualchar*GetInfo()
77. {
78. return"Wall";
79. }
80. };
82. classDoor:publicMapSite
83. {
84. public:
85. Door(Room*r1=0,Room*r2=0)
86. {
87. _room1=r1;
88. _room2=r2;
89. _isOpen=false;
90. }
92. Room*OtherSideFrom(Room*r)
93. {
94. if(r==_room1)
95. return_room2;
96. elseif(r==_room2)
97. return_room1;
99. return0;
100. }
102. virtualvoidEnter()
103. {
105. }
106. virtualchar*GetInfo()
107. {
108. return"Door";
109. }
110. private:
111. Room*_room1;
112. Room*_room2;
113. bool_isOpen;
114. };
116. classSpell
117. {
118. public:
119. Spell()
120. {}
121. };
123. classEnchantedRoom:publicRoom
124. {
125. public:
126. EnchantedRoom(introomNo,Spell*spell):Room(roomNo)
127. {
128. _spell=spell;
129. }
131. virtualvoidEnter()
132. {
134. }
135. virtualchar*GetInfo()
136. {
137. return"EnchantedRoom";
138. }
139. private:
140. Spell*_spell;
141. };
143. classDoorNeedingSpell:publicDoor
144. {
145. public:
146. DoorNeedingSpell(Room*r1,Room*r2):Door(r1,r2)
147. {
149. }
151. virtualvoidEnter()
152. {
154. }
155. virtualchar*GetInfo()
156. {
157. return"DoorNeedingSpell";
158. }
159. };
162. classRoomWithABomb:publicRoom
163. {
164. public:
165. RoomWithABomb(introomNo):Room(roomNo)
166. {
168. }
170. virtualvoidEnter()
171. {
173. }
174. virtualchar*GetInfo()
175. {
176. return"RoomWithABomb";
177. }
178. };
181. classBombedWall:publicWall
182. {
183. public:
184. BombedWall()
185. {
187. }
189. virtualvoidEnter()
190. {
192. }
193. virtualchar*GetInfo()
194. {
195. return"BombedWall";
196. }
197. };
200. classMaze
201. {
202. public:
203. Maze(intxsize=1,intysize=1)
204. {
205. if(xsize<=0||ysize<=0)
206. {
207. xsize=ysize=1;
208. }
210. _xsize=xsize;
211. _ysize=ysize;
213. _roomList=newRoom*[_xsize*_ysize];
215. for(inti=0;i<_xsize*_ysize;++i)
216. _roomList[i]=0;
218. }
220. voidAddRoom(Room*r)
221. {
222. intrno=r->RoomNo();
224. _roomList[rno]=r;
225. }
227. Room*RoomNo(intrno)const
228. {
229. for(inti=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. return0;
239. }
241. intXSize()const
242. {
243. return_xsize;
244. }
246. intYSzie()const
247. {
248. return_ysize;
249. }
251. intSize()const
252. {
253. return_xsize*_ysize;
254. }
256. ~Maze()
257. {
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. classBombedPartFactory;
11. classEnchantedPartFactory;
13. classPartFactory
14. {
15. public:
16. staticPartFactory*Instance();
18. staticvoidSetMazeStyle(std::stringstyle)
19. {
20. _mazeStyle=style;
21. }
22. private:
23. staticstd::string_mazeStyle;
24. staticPartFactory*_instance;
26. protected:
27. PartFactory(){}
29. public:
30. virtualRoom*MakeRoom(intrno)const
31. {
32. returnnewRoom(rno);
33. }
35. virtualWall*MakeWall()const
36. {
37. returnnewWall();
38. }
40. virtualDoor*MakeDoor(Room*r1,Room*r2)const
41. {
42. returnnewDoor(r1,r2);
43. }
45. };
48. classEnchantedPartFactory:publicPartFactory
49. {
50. public:
51. EnchantedPartFactory(){}
52. virtualRoom*MakeRoom(intrno)const
53. {
54. returnnewEnchantedRoom(rno,CastSpell());
55. }
57. virtualDoor*MakeDoor(Room*r1,Room*r2)const
58. {
59. returnnewDoorNeedingSpell(r1,r2);
60. }
62. protected:
63. Spell*CastSpell()const
64. {
65. return0;
66. }
67. };
69. classBombedPartFactory:publicPartFactory
70. {
71. public:
72. BombedPartFactory(){}
73. virtualRoom*MakeRoom(intrno)const
74. {
75. returnnewRoomWithABomb(rno);
76. }
78. virtualWall*MakeWall()const
79. {
80. returnnewBombedWall();
81. }
82. };
83. #endif

//

1. //PartFactory.cpp
3. #include"PartFactory.h"
6. PartFactory*PartFactory::_instance=0;
7. std::stringPartFactory::_mazeStyle;
9. PartFactory*PartFactory::Instance()
10. {
11. if(_instance==0)
12. {
13. if(_mazeStyle=="bombed")
14. _instance=newBombedPartFactory();
15. elseif(_mazeStyle=="enchanted")
16. _instance=newEnchantedPartFactory();
17. else
18. _instance=newPartFactory();
19. }
21. return_instance;
22. }

1. //MazeBuilder.h
3. #ifndef_MAZE_BUILDER_H_
4. #define_MAZE_BUILDER_H_
6. #include"PartFactory.h"
8. classMazeBuilder
9. {
10. public:
11. MazeBuilder()
12. {
13. BuildMaze();
14. }
16. voidBuildMaze()
17. {
18. _maze=newMaze(8,8);
19. _factory=PartFactory::Instance();
20. }
22. Maze*GetMaze()
23. {
24. return_maze;
25. }
27. virtualvoidBuildRoom(intrno)
28. {
29. //emtpy
30. }
32. virtualvoidBuildDoor(introomFrom,introomTo)
33. {
34. //emtpy
35. }
39. protected:
40. DirectionCommonWall(Room*r1,Room*r2)
41. {
42. intxs=_maze->XSize();
43. Directiondir;
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. returndir;
55. }
57. Maze*_maze;
58. PartFactory*_factory;
60. };
62. classStdMazeBuilder:publicMazeBuilder
63. {
64. public:
65. StdMazeBuilder(){}
67. virtualvoidBuildRoom(intrno)
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. virtualvoidBuildDoor(introomFrom,introomTo)
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. }
91. };
93. #endif

1. //MazeDrawer.h
3. #ifndef_MAZE_DRAW_H_
4. #define_MAZE_DRAW_H_
6. #include"Part.h"
7. #include<iostream>
9. classMazeDrawer
10. {
11. public:
12. virtualvoidDrawMaze(Maze*maze)
13. {
14. for(inti=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::stringdir;
21. for(intj=0;j<4;++j)
22. {
23. switch(j)
24. {
25. caseEast:
26. dir="East";
27. break;
28. caseSouth:
29. dir="South";
30. break;
31. caseWest:
32. dir="West";
33. break;
34. caseNorth:
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. classMazeGame
10. {
11. public:
12. MazeGame(MazeDrawer*md=0)
13. {
14. _mazeDrawer=md;
15. }
17. virtualMaze*CreateMaze(MazeBuilder&mb)=0;
18. voidDeleteMaze(Maze*maze)
19. {}
21. voidDrawMaze(Maze*maze)
22. {
23. if(_mazeDrawer!=0)
24. _mazeDrawer->DrawMaze(maze);
25. }
26. private:
27. MazeDrawer*_mazeDrawer;
28. };
30. classGame1:publicMazeGame
31. {
32. public:
33. Game1(MazeDrawer*md):MazeGame(md){}
35. virtualMaze*CreateMaze(MazeBuilder&mb)
36. {
37. for(inti=0;i<24;++i)
38. mb.BuildRoom(i);
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. returnmb.GetMaze();
51. }
52. };
53. #endif

/

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

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

希望通道中人提出意见建议，共同改善完善，共同交流：hm.y@live.cn