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

角色：

（1）Builder：是为创建一个Product对象的各个部件指定的抽象接口。

（2）ConcreteBuilder：是具体创建者，实现Builder接口，构造和装配各个部件。

（3）Product：具体的产品角色。

（4）Director：指挥者，他是构建一个使用Builder接口的对象。

Q：什么时候使用建造者模式？

A：它主要是用于创建一些复杂的对象，这些对象内部构造间的建造顺序通常是稳定的，但对象内部的构建通常面临着复杂的变化。

Q：使用建造者模式的好处？

A：建造者模式的好处就是使得建造代码与表示代码分离，由于建造者隐藏了 该产品是如何组装的，所以若需要改变一个产品的内部表示，只需要再定义一个具体的建造者就可以了。

  1 #include<string>
  2 #include<vector>
  3 #include<iostream>
  4 
  5 class Product{
  6 private:
  7     std::vector<std::string>  parts;
  8 public:
  9     void Add(std::string part){
 10         parts.push_back(part); 
 11     }
 12     void Show(){
 13     std::cout << "product building------------" << std::endl;
 14     std::vector<std::string>::iterator it;
 15     for (it = parts.begin(); it != parts.end(); it++){
 16         std::cout << *it << std::endl;
 17     }
 18 
 19     }
 20 };
 21 
 22 class Builder
 23 {
 24 public:
 25     virtual void BuildPartA() = 0;
 26     virtual void BuildPartB() = 0;
 27     virtual Product* GetResult() = 0;
 28 
 29 
 30 };
 31 
 32 
 33 class ConcreteBulider1:public Builder
 34 {
 35 private:
 36     Product* product;
 37 
 38 public:
 39     ConcreteBulider1(){
 40         product = new Product();
 41 
 42     }
 43     ~ConcreteBulider1(){
 44         delete product;
 45     }
 46     void BuildPartA(){
 47         product->Add("part A");
 48     }
 49     void BuildPartB(){
 50         product->Add("part B");
 51     }
 52     Product* GetResult(){
 53         return product;
 54     }
 55 
 56 };
 57 
 58 class ConcreteBulider2 :public Builder
 59 {
 60 private:
 61     Product* product;
 62 
 63 
 64 public:
 65     ConcreteBulider2(){
 66         product = new Product();
 67 
 68     }
 69     ~ConcreteBulider2(){
 70         delete product;
 71     }
 72     void BuildPartA(){
 73         product->Add("part X");
 74     }
 75     void BuildPartB(){
 76         product->Add("part Y");
 77     }
 78     Product* GetResult(){
 79         return product;
 80     }
 81 
 82 };
 83 
 84 class Director
 85 {
 86 public:
 87     void Construct(Builder* builder){
 88         builder->BuildPartA();
 89         builder->BuildPartB();
 90     }
 91 };
 92 
 93 
 94 //Client，客户不知道具体的建造过程。
 95 void main()
 96 {
 97     Director* director = new Director();
 98 
 99     Builder* builder1 = new ConcreteBulider1();
100     Builder* builder2 = new ConcreteBulider2();
101 
102     std::cout << "指挥者用ConcreteBuilder1的方法建造产品：" << std::endl;
103     director->Construct(builder1);
104     Product* p1 = builder1->GetResult();
105     p1->Show();
106     std::cout << std::endl;
107 
108     std::cout << "指挥者用ConcreteBuilder2的方法建造产品：" << std::endl;
109     director->Construct(builder2);
110     Product* p2 = builder2->GetResult();
111     p2->Show();
112     std::cout << std::endl;
113 
114     delete director;
115     delete builder1;
116     delete builder2;
117 
118     system("pause");
119 }

参考：

https://blog.csdn.net/xiqingnian/article/details/42005627