建造者模式（Builder）

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

对象的创建：Builder模式是为对象的创建而设计的一种模式，创建的是一个复合对象，被创建的对象为一个具有复合属性的复合对象。关注对象创建的各部分的创建过程，不同的工厂（这里指Builder生成器）对产品属性有不同的创建方法。

角色和职责

Builder Pattern结构图

Builder模式的关键是其中的Director对象并不直接返回对象，而是通过一步步（BuildPartA，BuildPartB，BuildPartC）来一步步进行对象的创建。当然这里Director可以提供一个默认的返回对象的接口（即返回通用的复杂对象的创建，即不指定或者特定唯一指定BuildPart中的参数）。

1) Builder : 为创建产品各个部分，同一抽象接口。

2) ConcreteBuilder : 具体创建产品的各个部分，部分A，部分B，部分C。

3) Director : 构造一个使用Builder接口的对象。
4) Product : 表示被构造的复杂对象。

ConcreteBuilder 创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

适用场景：当我们要创建的对象很复杂的时候（通常是由很多其他的对象组合而成），我们要要复杂对象的创建过程和这个对象的表示（展示）分离开来，这样做的好处就是通过一步步的进行复杂对象的构建，由于在每一步的构造过程中可以引入参数，使得经过相同的步骤创建最后得到的对象的展示不一样。

简单实现代码如下：

#include <iostream>
using namespace std;

//复杂对象的抽象类
class House
{
public:
    void setDoor(string door) { m_door = door; }
    void setWall(string wall) { m_wall = wall; }
    void setWindow(string window) { m_window = window; }

    string getDoor() { return m_door; }
    string getWall() { return m_wall; }
    string getWindow() { return m_window; }

private:
    string m_door;
    string m_wall;
    string m_window;
};

//工程队的抽象类
class Builder
{
public:
    virtual void buildDoor() = 0;
    virtual void buildWall() = 0;
    virtual void buildWindow() = 0;
    virtual House* getHouse() = 0;
};

//负责建造公寓的工程队的抽象
class FlatBuilder : public Builder
{
public:
    FlatBuilder() { m_pHouse = new House; }

    virtual void buildWindow()
    {
        m_pHouse->setWindow("FlatWindow");
    }
    virtual void buildWall()
    {
        m_pHouse->setWall("FlatWadll");
    }
    virtual void buildDoor()
    {
        m_pHouse->setDoor("FlatDoor");
    }
    virtual House* getHouse()
    {
        return m_pHouse;
    }

private:
    House *m_pHouse;
};

//负责建造别墅的工程队的抽象
class VillaBuilder : public Builder
{
public:
    VillaBuilder() { m_pHouse = new House; }

    virtual void buildWindow()
    {
        m_pHouse->setWindow("VillaWindow");
    }
    virtual void buildWall()
    {
        m_pHouse->setWall("VillaWadll");
    }
    virtual void buildDoor()
    {
        m_pHouse->setDoor("VillaDoor");
    }
    virtual House* getHouse()
    {
        return m_pHouse;
    }

private:
    House *m_pHouse;
};

//设计师（指挥者） 负责建造逻辑
//指挥建筑队干具体的活
class Director
{
public:
    Director(Builder *build)
    {
        m_pBuild = build;
    }
    void construct()
    {
        m_pBuild->buildWall();
        m_pBuild->buildWindow();
        m_pBuild->buildDoor();
    }

private:
    Builder *m_pBuild;
};

int main()
{
    Builder *builder = NULL;
    Director *dre = NULL;
    House *house = NULL;

    builder = new VillaBuilder();
    dre = new Director(builder);
    dre->construct();
    house = builder->getHouse();

    cout << (house->getWindow()).c_str() << endl;

    delete house;
    delete builder;
    delete dre;


    builder = new FlatBuilder();
    dre = new Director(builder);
    dre->construct();
    house = builder->getHouse();

    cout << (house->getWindow()).c_str() << endl;

    delete house;
    delete builder;
    delete dre;
    house = NULL;
    builder = NULL;
    dre = NULL;

    return 0;
}

总结

GoF在《设计模式》一书中给出的关于Builder模式的意图是非常容易理解、间接的：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示（在示例代码中可以通过传入不同的参数实现这一点）。

Builder模式和AbstractFactory模式在功能上很相似，因为都是用来创建大的复杂的对象，它们的区别是：Builder模式强调的是一步步创建对象，并通过相同的创建过程可以获得不同的结果对象，一般来说Builder模式中对象不是直接返回的。而在AbstractFactory模式中对象是直接返回的，AbstractFactory模式强调的是为创建多个相互依赖的对象提供一个同一的接口。