Builder建造者模式

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

    嗨，这个概念看起来总是这么深奥难懂。大概的意思，就是一套的构建过程可以有不同的产品（表示）出来。这些产品（表示）都按照这一套的构建过程被生产出来。

    建造者模式通常包括以下这几个角色：
    1、Builder：给出一个抽象接口，规范建造者对于生产的产品的各个组成部分的建造。这个接口只是定一个规范，不涉及具体的建造，具体的建造让继承于它的子类（ConcreteBuilder）去实现。
    2、ConcreteBuilder：实现builder接口，针对不同的商业逻辑，具体化各对象部分的建造，最后返回一个建造好的产品。
    3、Director：导演，顾名思义，负责规范流程之用。在指导中不涉及产品的创建，只负责保证复杂对象各部分被创建或按某种顺序创建。
    4、Product：复杂对象。
    按照惯例，给出建造者模式的UML图（这个先记下来，非常有用，学一个设计模式，先把这个图记下来！）
    
 
    使用建造者模式的好处
   1.使用建造者模式可以使客户端不必知道产品内部组成的细节。
    2.具体的建造者类之间是相互独立的，对系统的扩展非常有利。
    3.由于具体的建造者是独立的，因此可以对建造过程逐步细化，而不对其他的模块产生任何影响。

    使用建造者模式的场合:
     1.创建一些复杂的对象时，这些对象的内部组成构件间的建造顺序是稳定的，但是对象的内部组成构件面临着复杂的变化。
    2.要创建的复杂对象的算法，独立于该对象的组成部分，也独立于组成部分的装配方法时。

建造者模式的主要缺点 ：

建造者模式只能创建具有许多共同点的产品，组成成分相似如果产品内部组成复杂多变，将需要定义大量的建造者类，使得系统复杂化

#include  "stdafx.h" 
#include<iostream> 
#include<string>


using namespace std; 
 
 
//一个典型的复杂类对象代码示例如下：
class Product {
public:
      string partA;
 string partB;
 string partC;  


 void print()
 {
 cout <<"产品: "<< partA <<  partB <<  partC << endl;
 } 
};


//这是抽象的Builder：
  class Builder
  {
  public:
 virtual void  buildPartA()=0;
 virtual void  buildPartB() = 0;
 virtual  void buildPartC() = 0;
 virtual Product getProduct() = 0;
  };




//继承Builder的具体的建造者：
class ConcreteBuilder1  :public  Builder
{
private:
    Product   product;


public:
// 创建partA
 void buildPartA() 
   {
  product.partA=  "A1部件" ;
}
// 创建partB
   void buildPartB()
   { 
  product.partB= "B1部件";
}
// 创建partC
    void buildPartC()
{
product.partC = "C1部件";
}
// 返回复杂产品对象
Product getProduct()
{
return    product;
}
};




//继承Builder的具体的建造者：
class ConcreteBuilder2 :public  Builder
{
private:
Product   product;


public:
// 创建partA
void buildPartA()
{
product.partA = "A2部件";
}
// 创建partB
void buildPartB()
{
product.partB = "B2部件";
}
// 创建partC
void buildPartC()
{
product.partC = "C2部件";
}
// 返回复杂产品对象
Product getProduct()
{
return    product;
}
};






//这是导演，负责流程规范，在导演类中可以注入建造者对象。
class Director 
{


private:
Builder  * concretebuilder;
// 构造方法中也可以传递builder
public:
Director(Builder * builder) 
{
this->concretebuilder = builder;
}
 
// 这个方法用来规范流程，产品构建和组装方法
Product  construct()
{ 
concretebuilder->buildPartA();
concretebuilder->buildPartB();
concretebuilder->buildPartC();


return   concretebuilder->getProduct();
}
};
 
 


int main()
{
 
// 对于客户端而言，只需要关心具体的建造者，无需关心产品内部构建流程。
//我如果需要其他的复杂产品对象，只需要选择其他的建造者，如果需要扩展，则只需要写一个新的builder就行。
//如果可以，这个建造者甚至可以用配置文件做，增加更多的扩展性。
Builder *builder = new ConcreteBuilder1 ;


// 把建造者注入导演
Director  director(builder);


// 指挥者负责流程把控,返回一个组合好的复杂产品对象
Product  product =director.construct(); 
product.print();


//------------------------------------------------------------------------------------------------

Builder *builder2 = new ConcreteBuilder2;


// 把建造者注入导演
Director  director2(builder2);


// 指挥者负责流程把控,返回一个组合好的复杂产品对象
Product  product2 = director2.construct();
product2.print();
 
}