设计模式笔记--创建型模式之二 Builder

 

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

适用性：

1当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时

2 当构造过程必须允许被构造的对象有不同的表示时

效果：

1使你可以改变一个产品的内部表示，Builder提供给导向器一个构造产品的抽象接口，该接口可以隐藏这个产品的表示和内部结构。

2它将构造代码与表示代码分开，Builder模式通过封装一个复杂的对象的创建和表示发表过法提高了对象的模块性。每个ConcreteBuilder包含了创建和装配一个产品的所有代码，不同的Director可以复用相同部件集合的基础上构建不同的Product

3对构造过程进行精细控制，是在导向者的控制下一步一步构造产品的，当该产品完成时才从生成器取回。Builder接口更好的反映了产品的构造过程

实现：

1装配和构造接口 Builder接口必须足够普遍以便为各种类型的具体生成器构造产品

2产品没有抽象类

3Builder中缺省方法为空，不生明为纯虚成员函数，而是把它们定义为空方法，允许客户只定义他们所感兴趣的操作。

 

Abstract Factory与Builder比较

共同点 1创建复杂对象

不同点 1 Builder用于一步步构造一个复杂对象，并最终返回产品

              2 Abstract Factory用于多个系列产品的对象，立即返回产品

 

 代码如下：

Builder.h

1. #include <string>
2. #define MAX_ROOM_NO 30
4. enum Direction {North,South,East,West,Length};
6. class Mapsite
7. {
8. public:
9.   Mapsite(){}
10.   virtual ~Mapsite(){}
11.   virtual void Enter() = 0;
12. };
15. class Room : public Mapsite
16. {
17. public:
18.   Room(int roomNo);
19.   int GetRoomNo(){return roomNumber;}
20.   Mapsite* GetSide(Direction) const;
21.   void SetSide(Direction,Mapsite*);
22.   virtual void Enter();
23. private:
24.   Mapsite* _sides[4];
25.   int roomNumber;
26. };
28. class Wall:public Mapsite
29. {
30. public:
31.     Wall();
32.     virtual void Enter();
34. };
36. class Door:public Mapsite
37. {
38. public:
39.   Door(Room* = 0,Room* = 0);
40.   virtual void Enter();
41.   Room * OtherSideFrom(Room*);
42. private:
43.   Room* _room1;
44.   Room* _room2;
45.   bool _isOpen;
47. };
51. class Maze {
52. public:
53.     //Maze();
54.     void AddRoom(Room *);
55.     Room* RoomNo(int) const;
56. private:
57.     Room *a[MAX_ROOM_NO];
58. };
60. class MazeBuilder
61. {
62. public:
63.     virtual void BuildMaze(){}
64.     virtual void BuildRoom(int room){}
65.     virtual void BuildDoor(int roomFrom,int roomTo){}
66.     virtual Maze* GetMaze(){return 0;}
68. protected:
69.     //MazeBuilder();
70. };
72. class MazeGame
73. {
74. public:
75.     Maze* CreateMaze(MazeBuilder& builder);
76. };
78. class StandardMazeBuilder:public MazeBuilder
79. {
80. public:
81.     StandardMazeBuilder();
82.     virtual void BuildMaze();
83.     virtual void BuildRoom(int room);
84.     virtual void BuildDoor(int roomFrom,int roomTo);
85.     virtual Maze* GetMaze();
86. private:
87.     //Direction CommonWall(Room*,Room*);
88.     Maze* _currentMaze;
90. };

Builder.cpp

 

1. #include <iostream>
2. using namespace std;
3. #include "Builder.h"
4. string Direstr[Length] ={
5.     "North",
6.     "South",
7.     "East",
8.     "West"
9. };
11. Room::Room(int roomNo)
12. {
13.  cout<<"Make "<<roomNo<<" room"<<endl;
14.  roomNumber = roomNo;
15. }
18. void Room::SetSide(Direction dire,Mapsite* map)
19. {
20.  cout<<"Build a Wall on Direction "<<Direstr[dire]<<endl;
21. }
22. void Room::Enter()
23. {
24.  cout<<"Room enter"<<endl;
25. }
26. Wall::Wall()
27. {
28.  cout<<"Make a wall"<<endl;
29. }
31. void Wall::Enter()
32. {
33.  cout<<"Wall enter"<<endl;
34. }
36. void Door::Enter()
37. {
38.  cout<<"Door enter"<<endl;
39. }
40. void Maze::AddRoom(Room *r)
41. {
42.  cout<<"Add room to the maze!"<<endl;
43.  a[r->GetRoomNo()]=r;
44. }
46. Room* Maze::RoomNo(int roomNO) const
47. {
48.  for (int i=0;i<MAX_ROOM_NO;i++)
49.  { if (i == roomNO)
50.    if (!a[i])
51.     return a[i];
52.    else
53.     return 0;
54.  }
55.  return 0;
56. }
57. Door::Door(Room* r1,Room* r2)
58. {
59.  cout<<"A door is installed between 2 rooms"<<endl;
60. }
62. Maze* MazeGame::CreateMaze(MazeBuilder& builder)
63. {
64.     builder.BuildMaze();
65.     builder.BuildRoom(1);
66.     builder.BuildRoom(2);
67.     builder.BuildDoor(1,2);
68.     return builder.GetMaze();
69. }
70. void StandardMazeBuilder::BuildMaze()
71. {
72.   _currentMaze=new Maze;
73.   
74. }
75. Maze* StandardMazeBuilder::GetMaze()
76. {
77.     return _currentMaze;
78. }
79. void StandardMazeBuilder::BuildRoom(int n)
80. {
81.     if (!_currentMaze->RoomNo(n))
82.     {
83.         Room *room = new Room(n);
84.         _currentMaze->AddRoom(room);
85.         room->SetSide(North,new Wall);
86.         room->SetSide(South,new Wall);
87.         room->SetSide(East,new Wall);
88.         room->SetSide(West,new Wall);
89.     }
90. }
91. void StandardMazeBuilder::BuildDoor(int n1,int n2)
92. {
93.     Room *r1=_currentMaze->RoomNo(n1);
94.     Room *r2=_currentMaze->RoomNo(n2);
95.     Door *d = new Door(r1,r2);
96.     r1->SetSide(West,d);
97.     r2->SetSide(North,d);
99. }
101. StandardMazeBuilder::StandardMazeBuilder()
102. {
103.  _currentMaze = 0;
104. }

main.cpp

 

1. #include "Builder.h"
2. #include <iostream>
3. using namespace std;
4. int main()
5. {
6.     Maze* maze;
7.     cout<<"1"<<endl;
8.     MazeGame game;
9.     StandardMazeBuilder builder;
10.     game.CreateMaze(builder);
11.     maze = builder.GetMaze();
12.     return 0;
13. }