c++ 设计模式之创建者(生成器)模式

http://blog.youkuaiyun.com/lbqbraveheart/article/details/7083417

个人感觉这个模式，使用的应该较少，主要应用于流程性的东西，创建者负责构建一个对象的各个部分，并且完成组装的过程，可以这么理解，创建者模式类似与一个步骤基本固定，但是每个步骤的具体形式却又可以变化的这类对象的创建。废话不多说了，进入我们的创建者模式。

意图：

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

适用性：

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

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

使用创建者模式的基本方法：

1、需要抽象出一个基类，所有的对象创建时，都继承自这个基类创建。

2、需要创建一个调用的导演，由它来多态到不同的表现。（它并不继承自那个抽象基类，而是存储一个抽象基类的指针，类似多态）。

3、各个具体对象实例化基类的接口

看一个创建者模式的基本结构例子，本例子从http://www.cppblog.com/converse/archive/2006/07/21/10305.html，整理，仅供学习使用：

builder.h

[cpp]  view plain copy

1. //设计模式之builder模式  
2. /* 
3. 作用：将一个复杂对象的构建与它的表示分离，使同样的构建过程创建不同的表示 
4. */  
5. //虚拟基类，所有builder的基类，提供不同部分的构建接口  
6. class builder  
7. {  
8. public:  
9.     builder(){};  
10.     virtual ~builder(){};  
11.   
12.     //提供构建接口  
13.     virtual void builderA() = 0;  
14.     virtual void builderB() = 0;  
15. };  
16.   
17. //使用builder构建产品，构建产品的过程都一致，但是不同的builder会有不同的表现  
18. //这个不同的实现通过不同的builder派生类来实现，存有一个builder的指针，多态调用  
19. class director  
20. {//  
21. public:  
22.     director(builder *pbuilder);  
23.     virtual ~director();  
24.   
25.     void construct();  
26. private:  
27.     builder *pBuilder;  
28. };  
29. //具体实例化各个建造者  
30. class concretebuilder1:public builder  
31. {  
32. public:  
33.     concretebuilder1(){}  
34.     virtual ~concretebuilder1(){}  
35.     virtual void builderA();  
36.     virtual void builderB();  
37. };  
38. //具体实例化各个建造者  
39. class concretebuilder2:public builder  
40. {  
41. public:  
42.     concretebuilder2(){}  
43.     virtual ~concretebuilder2(){}  
44.   
45.     virtual void builderA();  
46.     virtual void builderB();  
47. };  

builder.cpp

[cpp]  view plain copy

1. #include "builder.h"  
2. #include <stdio.h>  
3.   
4. void concretebuilder1::builderA()  
5. {  
6.     printf("builderA by concretebuilder1\n");  
7. }  
8.   
9. void concretebuilder1::builderB()  
10. {  
11.     printf("builderB by concretebuilder1\n");  
12. }  
13.   
14. void concretebuilder2::builderA()  
15. {  
16.     printf("builderA by concretebuilder2\n");  
17. }  
18.   
19. void concretebuilder2::builderB()  
20. {  
21.     printf("builderB by concretebuilder2\n");  
22. }  
23.   
24. director::director(builder *pbuilder)  
25. {  
26.     this->pBuilder = pbuilder;  
27. }  
28. director::~director()  
29. {  
30.     delete pBuilder;  
31.     pBuilder = NULL;  
32. }  
33.   
34. void director::construct()  
35. {  
36.     //将同一个过程的表示组装一下  
37.     pBuilder->builderA();  
38.     pBuilder->builderB();  
39. }  
40.   
41.   
42. void main()  
43. {  
44.     //调用时，需要注意一下，具体想创建哪个表示，就实例化哪个  
45.     builder *pbuilder1 = new concretebuilder1;  
46.     //通过导演，可以将表示提取出来  
47.     director *pdirector = new director(pbuilder1);  
48.     //具体操作，就可以由导演代劳了。  
49.     pdirector->construct();  
50.   
51.     builder *pbuilder2 = new concretebuilder2;  
52.     director *pdirector2 = new director(pbuilder2);  
53.     pdirector2->construct();  
54.   
55.     delete pdirector;  
56.     delete pdirector2;  
57.   
58. }  

分析代码的时候主要看类的结构关系，以及具体的使用方法。

下面让我们看一个具体的例子。

例子主要从http://www.cnblogs.com/wanggary/archive/2011/04/15/2017615.html，得来的，仅供学习使用。

carbuilder.h

[cpp]  view plain copy

1. /* 
2. 客户模型： 
3. carmodel:汽车模型 
4. benmodel:奔驰汽车 
5. bmwmodel:宝马汽车 
6. carbuilder:建造者接口 
7. benbuilder：奔驰建造者 
8. bmwbuilder:宝马建造者 
9. director：导演 
10. */  
11.   
12. #include <vector>  
13. #include <string>  
14. #include <iostream>  
15. using namespace std;  
16.   
17. //首先虚拟出一个汽车模型  
18. class carmodel  
19. {  
20. public:  
21.     carmodel();  
22.     virtual ~carmodel();  
23.     void Run();  
24.     void SetSequence(vector<string> *pSeq);  
25.   
26. protected:  
27.     //定义出一系列操作  
28.     virtual void Start() = 0;  
29.     virtual void Stop() = 0;  
30.     virtual void Alarm() = 0;  
31.     virtual void EngineBoom() = 0;  
32. private:  
33.     vector<string> *m_pSequence;  
34. };  
35. //根据汽车模型构建奔驰汽车  
36. class benmodel:public carmodel  
37. {  
38. public:  
39.     benmodel();  
40.     ~benmodel();  
41. protected:  
42.     void Start();  
43.     void Stop();  
44.     void Alarm();  
45.     void EngineBoom();  
46.   
47. };  
48. //根据汽车模型构建宝马汽车  
49. class bmwmodel:public carmodel  
50. {  
51. public:  
52.     bmwmodel();  
53.     ~bmwmodel();  
54. protected:  
55.     void Start();  
56.     void Stop();  
57.     void Alarm();  
58.     void EngineBoom();  
59.   
60. };  
61. //虚拟出一个汽车的建造者模型  
62. //类似于上面说的那个抽象基类  
63. class carbuilder  
64. {  
65. public:  
66.     carbuilder()  
67.     {  
68.   
69.     }  
70.     virtual ~carbuilder()  
71.     {  
72.   
73.     }  
74.     virtual void SetSequence(vector<string> *pSeq) = 0;  
75.     virtual carmodel* GetCarModel() = 0;  
76. };  
77. //创建一个奔驰汽车  
78. class benbuilder:public carbuilder  
79. {  
80. public:  
81.     benbuilder();  
82.     ~benbuilder();  
83.     void SetSequence(vector<string> *pSeq);  
84.     carmodel* GetCarModel();  
85. private:  
86.     carmodel *pBen;  
87. };  
88. //创建一个奔驰汽车  
89. class bmwbuilder:public carbuilder  
90. {  
91. public:  
92.     bmwbuilder();  
93.     ~bmwbuilder();  
94.     void SetSequence(vector<string> *pSeq);  
95.     carmodel* GetCarModel();  
96. private:  
97.     carmodel *pBmw;  
98. };  
99.   
100. //这个就是导演,  
101. class director  
102. {  
103. public:  
104.     director();  
105.     ~director();  
106.     benmodel* GetABenModel();  
107.     benmodel* GetBBenModel();  
108.     bmwmodel* GetCBmwModel();  
109.     bmwmodel* GetDBmwModel();  
110. private:  
111.     vector<string> *pSequence;  
112.     benbuilder *pBen;  
113.     bmwbuilder *pBmw;  
114. };  

carbuilder.cpp

[cpp]  view plain copy

1. #include"carbuilder.h"  
2. carmodel::carmodel()  
3. {  
4.   
5. }  
6. carmodel::~carmodel()  
7. {  
8.   
9. }  
10. void carmodel::SetSequence(vector<string> *pSeq)  
11. {  
12.     m_pSequence = pSeq;  
13. }  
14. void carmodel::Run()  
15. {  
16.     vector<string>::const_iterator it = m_pSequence->begin();  
17.     for(;it != m_pSequence->end();++it )  
18.     {  
19.         string actionName = *it;  
20.         if(actionName.compare("start") == 0)  
21.         {  
22.             Start();  
23.         }  
24.         else if(actionName.compare("stop") == 0)  
25.         {  
26.             Stop();  
27.         }  
28.         else if(actionName.compare("alarm") == 0)  
29.         {  
30.             Alarm();  
31.         }  
32.         else if(actionName.compare("engine boom") == 0)  
33.         {  
34.             EngineBoom();  
35.         }  
36.     }  
37. }  
38.   
39. benmodel::benmodel()  
40. {  
41.   
42. }  
43. benmodel::~benmodel()  
44. {  
45.   
46. }  
47. void benmodel::Start()  
48. {  
49.     cout<<"ben start..."<<endl;  
50. }  
51. void benmodel::Stop()  
52. {  
53.     cout<<"ben stop..."<<endl;  
54. }  
55. void benmodel::Alarm()  
56. {  
57.     cout<<"ben alarm..."<<endl;  
58. }  
59. void benmodel::EngineBoom()  
60. {  
61.     cout<<"ben engineboom..."<<endl;  
62. }  
63.   
64. bmwmodel::bmwmodel()  
65. {  
66.   
67. }  
68. bmwmodel::~bmwmodel()  
69. {  
70.   
71. }  
72. void bmwmodel::Start()  
73. {  
74.     cout<<"bmw start..."<<endl;  
75. }  
76. void bmwmodel::Stop()  
77. {  
78.     cout<<"bmw stop..."<<endl;  
79. }  
80. void bmwmodel::Alarm()  
81. {  
82.     cout<<"bmw alarm..."<<endl;  
83. }  
84. void bmwmodel::EngineBoom()  
85. {  
86.     cout<<"bmw engineboom..."<<endl;  
87. }  
88.   
89. benbuilder::benbuilder()  
90. {  
91.     //在构造函数中创建奔驰汽车的模型  
92.     pBen = new benmodel();  
93. }  
94. benbuilder::~benbuilder()  
95. {  
96.   
97. }  
98. carmodel* benbuilder::GetCarModel()  
99. {  
100.     return pBen;  
101. }  
102. void benbuilder::SetSequence(vector<string> *pSeq)  
103. {  
104.     pBen->SetSequence(pSeq);  
105. }  
106.   
107. bmwbuilder::bmwbuilder()  
108. {  
109.     //在构造函数中创建宝马汽车的模型  
110.     pBmw = new bmwmodel();  
111. }  
112. bmwbuilder::~bmwbuilder()  
113. {  
114.   
115. }  
116. carmodel* bmwbuilder::GetCarModel()  
117. {  
118.     return pBmw;  
119. }  
120. void bmwbuilder::SetSequence(vector<string> *pSeq)  
121. {  
122.     pBmw->SetSequence(pSeq);  
123. }  
124.   
125. director::director()  
126. {  
127.     pBen = new benbuilder();  
128.     pBmw = new bmwbuilder();  
129.     pSequence = new vector<string>();  
130. }  
131. director::~director()  
132. {  
133.     delete pBen;  
134.     delete pBmw;  
135.     delete pSequence;  
136. }  
137. benmodel * director::GetABenModel()  
138. {  
139.     pSequence->clear();  
140.     pSequence->push_back("start");  
141.     pSequence->push_back("stop");  
142.     pBen->SetSequence(pSequence);  
143.     return dynamic_cast<benmodel*>(pBen->GetCarModel());  
144. }  
145. benmodel * director::GetBBenModel()  
146. {  
147.     pSequence->clear();  
148.     pSequence->push_back("start");  
149.     pSequence->push_back("Alarm");  
150.     pSequence->push_back("Stop");  
151.     pBen->SetSequence(pSequence);  
152.     return dynamic_cast<benmodel*>(pBen->GetCarModel());  
153. }  
154. bmwmodel *director::GetCBmwModel()  
155. {  
156.     pSequence->clear();  
157.     pSequence->push_back("start");  
158.     pSequence->push_back("stop");  
159.     pBmw->SetSequence(pSequence);  
160.     return dynamic_cast<bmwmodel*>(pBmw->GetCarModel());  
161. }  
162.   
163. bmwmodel *director::GetDBmwModel()  
164. {  
165.     pSequence->clear();  
166.     pSequence->push_back("start");  
167.     pSequence->push_back("Engineboom");  
168.     pBmw->SetSequence(pSequence);  
169.     return dynamic_cast<bmwmodel*>(pBmw->GetCarModel());  
170. }  
171. int main()  
172. {  
173.     director *pdir = new director;  
174.   
175.     benmodel *pben = pdir->GetABenModel();  
176.     pben->Run();  
177.   
178.     bmwmodel *pbmw = pdir->GetCBmwModel();  
179.     pbmw->Run();  
180.     delete pdir;  
181.     return 0;  
182. }