设计模式 - Builder模式（建造者模式）

 

Builder模式（建造者模式）：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

 

适用于以下情况：

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

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

 

uml图

 

 

抽象基类:

1)Builder:这个基类是全部创建对象过程的抽象,提供构建不同组成部分的接口函数

接口:

1)Builder::BuildPartA,Builder::BuildPartB:是对一个对象不同部分的构建函数接口,Builder的派生类来具体实现.

另外还有一个需要注意的函数,就是Director::Construct函数,这个函数里面通过调用上面的两个接口函数完成对象的构建--也就是说各个不同部分装配的过程都是一致的(同样的调用Construct函数),但是不同的构建方式会有不同的表示(根据Builder的实际类型来决定如何构建,也就是多态)

解析:

Builder模式是基于这样的一个情况:一个对象可能有不同的组成部分,这几个部分的不同的创建对象会有不同的表示,但是各个部分之间装配的方式是一致的.比方说一辆单车,都是由车轮车座等等的构成的(一个对象不同的组成部分),不同的品牌生产出来的也不一样(不同的构建方式).虽然不同的品牌构建出来的单车不同,但是构建的过程还是一样的(哦,你见过车轮长在车座上的么?).也就是说,Director::Construct函数中固定了各个组成部分的装配方式,而具体是装配怎样的组成部分由Builder的派生类实现.

实现:

Builder模式的实现基于以下几个面向对象的设计原则:

1)把变化的部分提取出来形成一个基类和对应的接口函数,在这里不会变化的是都会创建PartA 和PartB,变化的则是不同的创建方法,于是就抽取出这里的Builder基类和BuildPartA,BuildPartB接口函数

2)采用聚合的方式聚合了会发生变化的基类,就是这里 Director聚合了Builder类的指针.

 

示例代码：

 

 1 
 2 #ifndef BUILDER_H
 3 #define BUILDER_H
 4 
 5 // 虚拟基类,是所有Builder的基类,提供不同部分的构建接口函数
 6 class Builder
 7 {
 8 public:
 9     Builder(){};
10     virtual ~Builder(){}
11 
12     // 纯虚函数,提供构建不同部分的构建接口函数
13     virtual void BuilderPartA() = 0;
14     virtual void BuilderPartB() = 0;
15 };
16 
17 // 使用Builder构建产品,构建产品的过程都一致,但是不同的builder有不同的实现
18 // 这个不同的实现通过不同的Builder派生类来实现,存有一个Builder的指针,通过这个来实现多态调用
19 class Director
20 {
21 public:
22     Director(Builder* pBuilder);
23     ~Director();
24 
25     void Construct();
26 
27 private:
28     Builder* m_pBuilder;
29 };
30 
31 // Builder的派生类,实现BuilderPartA和BuilderPartB接口函数
32 class ConcreateBuilder1
33     : public Builder
34 {
35 public:
36     ConcreateBuilder1(){}
37     virtual ~ConcreateBuilder1(){}
38 
39     virtual void BuilderPartA();
40     virtual void BuilderPartB();
41 };
42 
43 // Builder的派生类,实现BuilderPartA和BuilderPartB接口函数
44 class ConcreateBuilder2
45     : public Builder
46 {
47 public:
48     ConcreateBuilder2(){}
49     virtual ~ConcreateBuilder2(){}
50 
51     virtual void BuilderPartA();
52     virtual void BuilderPartB();
53 };
54 
55 #endif

 

 

 

 1 #include "Builder.h"
 2 #include <iostream>
 3 
 4 void ConcreateBuilder1::BuilderPartA()
 5 {
 6     std::cout << "BuilderPartA by ConcreateBuilder1\n";
 7 }
 8 
 9 void ConcreateBuilder1::BuilderPartB()
10 {
11     std::cout << "BuilderPartB by ConcreateBuilder1\n";
12 }
13 
14 void ConcreateBuilder2::BuilderPartA()
15 {
16     std::cout << "BuilderPartA by ConcreateBuilder2\n";
17 }
18 
19 void ConcreateBuilder2::BuilderPartB()
20 {
21     std::cout << "BuilderPartB by ConcreateBuilder2\n";
22 }
23 
24 Director::Director(Builder* pBuilder)
25     : m_pBuilder(pBuilder)
26 {
27 }
28 
29 Director::~Director()
30 {
31     delete m_pBuilder;
32     m_pBuilder = NULL;
33 }
34 
35 // Construct函数表示一个对象的整个构建过程,不同的部分之间的装配方式都是一致的,
36 // 首先构建PartA其次是PartB,只是根据不同的构建者会有不同的表示
37 void Director::Construct()
38 {
39     m_pBuilder->BuilderPartA();
40     m_pBuilder->BuilderPartB();
41 }

 

 

 1 
 2 #include "Builder.h"
 3 #include <stdlib.h>
 4 
 5 int main()
 6 {
 7     Builder* pBuilder1 = new ConcreateBuilder1;
 8     Director *pDirector1 = new Director(pBuilder1);
 9     pDirector1->Construct();
10 
11     Builder* pBuilder2 = new ConcreateBuilder2;
12     Director *pDirector2 = new Director(pBuilder2);
13     pDirector2->Construct();
14 
15     delete pDirector1;
16     delete pDirector2;
17 
18     system("pause");
19 
20     return 0;
21 }