3. Builder（建造者）

3.1 定义

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

3.2 适用场景

　　使用建造者模式的典型场景如下。

　　■ 相同的方法，不同的执行顺序，产生不同的结果时，可以采用建造者模式。

　　■ 多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时，则可以使用该模式。

　　■ 产品类非常复杂，或者产品类中的方法调用顺序不同产生了不同的效能，这个时候使用建造者模式。

　　■ 在对象创建过程中会使用到系统的一些其他对象，这些对象在产品对象的创建过程中不易得到时，也可以采用建造者模式封装该对象的创建过程。该种场景只能是一个补偿方法，因为一个对象不容易获得，而在设计阶段没有发现，要通过创建者模式柔化创建过程，本身已经违反设计的最初目标。

3.3 c++源码

  1 #include <iostream>
  2 #include <string>
  3 
  4 using namespace std;
  5 
  6 // 一个产品由零件1 零件2 构成
  7 //具体的产品类
  8 class Product
  9 {
 10 public:
 11     void setPart1(string part1)
 12     {
 13         m_part1 = part1;
 14     }
 15 
 16     void setPart2(string part2)
 17     {
 18         m_part2 = part2;
 19     }
 20 
 21     string getPart1(){
 22         cout << m_part1 << endl;
 23         return m_part1;
 24     }
 25 
 26     string getPart2(){
 27         cout << m_part2 << endl;
 28         return m_part2;
 29     }
 30 
 31 private:
 32     string m_part1;
 33     string m_part2;
 34 };
 35 
 36 //抽象建造类，提供建造接口。
 37 class OrderBuilder
 38 {
 39 public:
 40     virtual ~OrderBuilder()
 41     {
 42         cout << "~OrderBuilder()" << endl;
 43     }
 44     virtual void setOrderPart1() = 0;
 45     virtual void setOrderPart2() = 0;
 46     virtual Product* getProduct() = 0;
 47 };
 48 
 49 //具体的建造类
 50 class FirstOrderBuilder : public OrderBuilder
 51 {
 52 public:
 53     FirstOrderBuilder()
 54     {
 55         m_Product = new Product;
 56     }
 57 
 58     ~FirstOrderBuilder()
 59     {
 60         cout << "~FirstOrderBuilder()" << endl;
 61         delete m_Product;
 62         m_Product = NULL;
 63     }
 64 
 65     void setOrderPart1()
 66     {
 67         m_Product->setPart1("first part1");
 68     }
 69 
 70     void setOrderPart2()
 71     {
 72         m_Product->setPart2("first part2");
 73     }
 74 
 75     Product* getProduct()
 76     {
 77         return m_Product;
 78     }
 79 
 80 private:
 81     Product* m_Product;
 82 };
 83 
 84 //具体的建造类
 85 class SecondOrderBuilder : public OrderBuilder
 86 {
 87 public:
 88     SecondOrderBuilder()
 89     {
 90         m_Product = new Product;
 91     }
 92 
 93     ~SecondOrderBuilder()
 94     {
 95         cout << "~SecondOrderBuilder()" << endl;
 96         delete m_Product;
 97         m_Product = NULL;
 98     }
 99 
100     void setOrderPart1()
101     {
102         m_Product->setPart1("second part1");
103     }
104 
105     void setOrderPart2()
106     {
107         m_Product->setPart2("second part2");
108     }
109 
110     Product* getProduct()
111     {
112         return m_Product;
113     }
114 
115 private:
116     Product* m_Product;
117 };
118 
119 //Director类，负责管理实例创建的依赖关系，指挥构建者类创建实例
120 class Director
121 {
122 public:
123     Director(OrderBuilder* builder) : m_pOrderBuilder(builder)
124     {
125     }
126     void construct()
127     {
128         m_pOrderBuilder->setOrderPart1();
129         m_pOrderBuilder->setOrderPart2();
130     }
131 
132 private:
133     OrderBuilder* m_pOrderBuilder;
134 };
135 
136 
137 int main()
138 {
139     OrderBuilder* mBuilder = new SecondOrderBuilder;
140     Director* director = new Director(mBuilder);
141     director->construct();
142     Product* order = mBuilder->getProduct();
143     order->getPart1();
144     order->getPart2();
145 
146     delete director;
147     director = NULL;
148 
149     delete mBuilder;
150     mBuilder = NULL;
151 
152 return 0;
153 }