Builder模式也叫建造者模式或者生成器模式，是由GoF提出的23种设计模式中的一种。Builder模式是一种对象创建型模式之一，用来隐藏复合对象的创建过程，它把复合对象的创建过程加以抽象，通过子类继承和重载的方式，动态地创建具有复合属性的对象。

对象的创建：Builder模式是为对象的创建而设计的模式

创建的是一个复合对象：被创建的对象为一个具有复合属性的复合对象

关注对象创建的各部分的创建过程：不同的工厂（这里指builder生成器）对产品属性有不同的创建方法。

在软件系统中，有时候面临着“一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将他们组合在一起的算法却相对稳定。

如何应对这种变化？如何提供一种“封装机制”来隔离出“复杂对象的各个部分”的变化，从而保持系统中的“稳定构建算法”不随着需求改变而改变。

class House{
    //....

     House(){ // 错误示例，不能这样写

        this->BuildPart1(); // 构造函数中是静态绑定，此时调用纯虚函数会报错，不会去调用子类

        for (int i = 0; i < 4; i++){
            this->BuildPart2();
        }

        bool flag = pHouseBuilder->BuildPart3();

        if (flag){
            this->BuildPart4();
        }

        this->BuildPart5();
    }

    void Init(){ // 流程相对固定

        this->BuildPart1(); // 构造第一部分

        for (int i = 0; i < 4; i++){
            this->BuildPart2();
        }

        bool flag = pHouseBuilder->BuildPart3();

        if (flag){
            this->BuildPart4();
        }

        this->BuildPart5();        
    }
    virtual ~HouseBuilder(){}
protected:    
    virtual void BuildPart1() = 0;
    virtual void BuildPart2() = 0;
    virtual void BuildPart3() = 0;
    virtual void BuildPart4() = 0;
    virtual void BuildPart5() = 0;
};

C++构造函数中，是不会去调用子类的虚函数。
子类构造函数会先去调用父类构造函数，如果子类调用父类构造，父类构造中去寻找子类虚函数，会报错，因为子类构造函数还没有完成，子类虚函数先被调用，这违背对象的构造原理

class StoneHouse: public House{　　//各种房子

protected:

    virtual void BuildPart1(){
        //pHouse->Part1 = ...;
    }
    virtual void BuildPart2(){

    }
    virtual void BuildPart3(){

    }
    virtual void BuildPart4(){

    }
    virtual void BuildPart5(){

    }
};

　　将一个复杂对象的构建与其表示相分离，使得同样的构建过程（稳定）可以创建不同的表示（变化）。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　--《设计模式》Gof　　　

Init就是同一个构建过程，而每一个对象我们只需要实现其构建步骤就可以创建不同的表示

int main()
{
    House* pHouse = new StoneHouse();
    pHouse->Init();
}

class House{ // 表示　　抽象基类
    //.... house 与 HouseBuilder 相分离
};

class HouseBuilder {  // 构建　　抽象基类
public:
    House* GetResult(){
        return pHouse;
    }
    virtual ~HouseBuilder(){}
protected:
    
    House* pHouse;
    virtual void BuildPart1()=0;
    virtual void BuildPart2()=0;
    virtual void BuildPart3()=0;
    virtual void BuildPart4()=0;
    virtual void BuildPart5()=0;
    
};

class StoneHouse: public House{
    
};

class StoneHouseBuilder: public HouseBuilder{
protected:
    
    virtual void BuildPart1(){
        //pHouse->Part1 = ...;
    }
    virtual void BuildPart2(){
        
    }
    virtual void BuildPart3(){
        
    }
    virtual void BuildPart4(){
        
    }
    virtual void BuildPart5(){
        
    }
    
};

// 稳定
class HouseDirector{  // 同样的构建过程
    
public:
    HouseBuilder* pHouseBuilder;
    
    HouseDirector(HouseBuilder* pHouseBuilder){
        this->pHouseBuilder=pHouseBuilder;
    }
    
    House* Construct(){
        
        pHouseBuilder->BuildPart1();
        
        for (int i = 0; i < 4; i++){
            pHouseBuilder->BuildPart2();
        }
        
        bool flag=pHouseBuilder->BuildPart3();
        
        if(flag){
            pHouseBuilder->BuildPart4();
        }
        
        pHouseBuilder->BuildPart5();
        
        return pHouseBuilder->GetResult();
    }
};

HouseBuilder管构建，House将其分离出去，而创建步骤又是稳定的，我们再一步进行拆分为HouseDiretor,避免类的肥大

类复杂就拆分，类简单就合并

1.有一个抽象的工厂。
2.实现一个具体的工厂---汽车工厂。
3.工厂生产汽车A，得到汽车产品A。
4.工厂生产汽车B，得到汽车产品B。

这样做，实现了购买者和生产线的隔离。

1.离合器工厂生产离合器产品，得到汽车部件A。
2.轮胎工厂生产轮子产品，得到汽车部件B。
3.车身工厂生产车身产品，得到汽车部件C。
4.将这些部件放到一起，形成刚好能够组装成一辆汽车的整体。
5.将这个整体送到汽车组装工厂，得到一个汽车产品。

或者更抽象一点理解：
1.将汽车的每一个零件都送到汽车组装工厂。
2.在工厂里，组装离合器，得到汽车部件A。
3.在工厂里，组装轮胎，得到汽车部件B。
4.在工厂里，组装车身，得到汽车部件C。
5.在工厂里，组装每个部件，得到一个汽车产品。

这样做，目的是为了实现复杂对象生产线和其部件的解耦。

Factory模式不考虑对象的组装过程，而直接生成一个我想要的对象。
Builder模式先一个个的创建对象的每一个部件，再统一组装成一个对象。
Factory模式所解决的问题是，工厂生产产品。而Builder模式所解决的问题是工厂控制产品生成器组装各个部件的过程，然后从产品生成器中得到产品。

class House
{
private:
    string m_floor;
    string m_wall;
    string m_door;
public:
    void setFloor(string floor)
    {
        this->m_floor = floor;
    }

    void setWall(string wall)
    {
        this->m_wall = wall;
    }

    void setDoor(string door)
    {
        this->m_door = door;
    }

    void getFloor()
    {
        cout << "install " << this->m_floor << endl;
    }

    void getWall()
    {
        cout << "install " << this->m_wall << endl;
    }

    void getDoor()
    {
        cout << "install " << this->m_door << endl;
    }
};

class HouseBuilder
{
protected:
    House* pHouse;

public:
    virtual void BuildFloor() = 0;
    virtual void BuildWall() = 0;
    virtual void BuildDoor() = 0;

    House* GetResult()
    {
        return pHouse;
    }
};

class HouseDirector
{
public:
    HouseBuilder* pHouseBuilder;

    HouseDirector(HouseBuilder* pHouseBuilder)
    {
        this->pHouseBuilder = pHouseBuilder;
    }

    House* Construct()
    {
        pHouseBuilder->BuildWall();
        pHouseBuilder->BuildFloor();
        pHouseBuilder->BuildDoor();
        return pHouseBuilder->GetResult();
    }
};

class StoneHouseBuilder :public HouseBuilder
{
public:
    StoneHouseBuilder()
    {
        pHouse = new House();
    }

    virtual void BuildFloor()
    {
        pHouse->setFloor("stone floor");
    }

    virtual void BuildWall()
    {
        pHouse->setWall("stone wall");
    }

    virtual void BuildDoor()
    {
        pHouse->setDoor("stone door");
    }
};

class FlatHouseBuilder :public HouseBuilder
{
public:
    FlatHouseBuilder()
    {
        pHouse = new House();
    }

    virtual void BuildFloor()
    {
        pHouse->setFloor("flat floor");
    }

    virtual void BuildWall()
    {
        pHouse->setFloor("flat wall");
    }

    virtual void BuildDoor()
    {
        pHouse->setFloor("flat door");
    }
};

void main()
{
    HouseBuilder* HB = new StoneHouseBuilder();
    HouseDirector* HD = new HouseDirector(HB);
    House* H = HD->Construct();

    H->getWall();
    H->getFloor();
    H->getDoor();

    delete H;
    delete HB;
    delete HD;

    system("pause");
    return;
}