创建者模式

建造者模式也叫生成器模式，是由GoF提出的23种设计模式中的一种。Builder模式是一种对象创建型模式，用来隐藏复合对象的创建过程，它把复合对象的创建过程加以抽象，通过子类继承和重载的方式，动态地创建具有复合属性的对象。
　　对象的创建：Builder模式是为对象的创建而设计的模式- 创建的是一个复合对象：关注对象各部分的创建过程：不同的工厂（这里指builder（创建者）／生成器）对产品属性有不同的创建方法。
适用情况：
一个对象的构建比较复杂，将一个对象的构建(?)和对象的表示(?)进行分离。
对象的构建：对象进行各部件生产和组装的过程，表现为具体工厂生产具体产品的函数。
对象的表示：变现为一个具体的产品类。
角色及职责


Builder：
为创建产品各个部分，统一抽象接口。
ConcreteBuilder：
具体的创建产品的各个部分，部分A， 部分B，部分C。
Director：
构造一个使用Builder接口的对象。扮演导演和总指挥的角色，指挥抽象工厂生产产品，而由于多态，抽象工厂实际使用的是具体工厂对象的构建方法。决定了各部件之间的生产和组装逻辑！
Product：
表示被构造的复杂对象。里面有多个部件，需要在ConcreteBuilder里面单独进行生产和组装。
ConcreteBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。
和工厂方法模式的区别
Factory模式中：
1、有一个抽象的工厂。
2、实现一个具体的工厂—汽车工厂。
3、工厂生产汽车A，得到汽车产品A。
4、工厂生产汽车B，得到汽车产品B。
这样做，实现了购买者和生产线的隔离。强调的是结果。
Builder模式:
1、引擎工厂生产引擎产品，得到汽车部件A。
2、轮胎工厂生产轮子产品，得到汽车部件B。
3、底盘工厂生产车身产品，得到汽车部件C。
4、将这些部件放到一起，形成刚好能够组装成一辆汽车的整体。
5、将这个整体送到汽车组装工厂，得到一个汽车产品。
这样做，目的是为了实现复杂对象生产线和其部件的解耦。强调的是过程
两者的区别在于：
Factory模式不考虑对象的组装过程，而直接生成一个我想要的对象。
Builder模式先一个个的创建对象的每一个部件，再统一组装成一个对象。
Factory模式所解决的问题是，工厂生产产品。
而Builder模式所解决的问题是工厂控制产品生成器组装各个部件的过程，然后从产品生成器中得到产品。Builder模式不是很常用。
案例

#include<iostream>using namespace std;/*对象的表示*/class House{public:    void setDoor(string door)    {        this->m_door = door;    }    void setWall(string wall)    {        this->m_wall = wall;    }    void setWindow(string window)    {        this->m_window = window;    }    //--    string getDoor( )    {        cout << m_door << endl;        return this->m_door ;    }    string getWall()    {        cout << m_wall << endl;        return this->m_wall;    }    string getWindow()    {        cout << m_window << endl;        return m_window;    }private:    string  m_door;    string  m_wall;    string  m_window;};/*对象的构建--抽象接口--建筑团队--干具体的活--被设计师调用指挥*/class Builder{public:    virtual void buildWall()=0;    virtual void buildDoor()=0;    virtual void buildWindow()=0;    virtual House* getHouse()=0;};/*对象的构建1--实现所有组件的构建功能--具体的构建者*/class FlatBuilder:public Builder{public:    FlatBuilder()    {        m_house = new House;    }    virtual void buildWall()    {        m_house->setWall("flat wall");    }    virtual void buildDoor()    {        m_house->setDoor("flat door");    }    virtual void buildWindow()    {         m_house->setWindow("flat window");    }    virtual House* getHouse()    {        return m_house;    }private:    House* m_house;};/*对象的构建2--实现所有组件的构建功能--具体的构建者*/class VillaBuilder:public Builder{public:    VillaBuilder()    {        m_house = new House;    }    virtual void buildWall()    {        m_house->setWall("villa wall");    }    virtual void buildDoor()    {        m_house->setDoor("villa door");    }    virtual void buildWindow()    {         m_house->setWindow("villa window");    }    virtual House* getHouse()    {        return m_house;    }private:    House* m_house;};/*设计师--负责建造逻辑（对象如何构建，构建顺序如何都与对象的表示无关） * --指挥抽象的构建者--建筑团队实现了对象的构建和对象的表示之间的解耦合（分离）*/class Director{public:    Director(Builder* builder)    {        m_build = builder;    }    void Constructor()    {        m_build->buildWall();        m_build->buildWindow();        m_build->buildDoor();    }private:    Builder * m_build;};/*测试案例*/int main262(){    /*请一个建筑团队--抽象构建者*/    Builder * builder = new VillaBuilder;//具体构建者    /*设计师指挥建筑团队干活--设计师--对象的构建*/    Director * director = new Director(builder);//指挥（依赖）抽象构建者    director->Constructor();//构建对象    /*具体产品--对象的表示*/    House * house = builder->getHouse();    /*展示对象*/    house->getDoor();    house->getWall();    house->getWindow();    delete house;//内存回收    delete builder;    builder = new FlatBuilder;//更换具体构建者    director = new Director(builder);//再次指挥（新的）抽象构建者    director->Constructor();//构建对象    /*对象的表示*/    house = builder->getHouse();    house->getDoor();    house->getWall();    house->getWindow();    delete house;    delete builder;    delete director;//内存回收    return 0;}