构建者模式

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示

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

例如说一部手机，先放主板，再放屏幕，再放电池，再放外壳，贴个膜就能卖几千了，每次推出新产品，就换个更好的主板，换个大点的屏幕，再整个大容量电池，贴个超牛B的高透膜，又能卖出个新价钱。就是说，这些步骤都没有变，变的只是每个部分的东西。

又如:创建一个窗口控件(Widget)时，往往都要初始化UI、初始化动画、初始化信号和槽，这些构造的接口,构造的顺序是固定的，而变化的是具体的实现过程

建造者模式的定义中构建指的就是生产一个产品的步骤，表示就是每个产品部分的具体实现，通过Director封装步骤，通过Builder封装产品部分的实现，再把他两隔离开，就能隔离变的，留出不变的供客户端使用。

Builder模式的关键是其中的Director对象并不是直接返回对象，而是通过一步步进行对象的构建。

构建者模式和抽象工厂模式的比较:

两者功能相似，都用来创建复杂的对象，但是构建者模式更加强调一步一步构建对象，并通过相同的构建步骤得到不同的结果对象，一般来说构建者模式的对象不是直接返回的，而抽象工厂模式的创建的对象时直接返回的，它强调的是为创建多个相互依赖的对象提供统一的接口

代码:

#include <iostream>
#include <string>
using namespace std;

class House
{
public:
    ~House()
    {
        cout << "House 被析构" << endl;
    }
public:
    void setWall(const string & wall)
    {
        _wall = wall;
    }

    void setWindow(const string &window)
    {
        _window = window;
    }

    void setDoor(const string &door)
    {
        _door = door;
    }

    void show()
    {
        cout << "Wall: " << _wall << " Window: " << _window << " Door: " << _door << endl;
    }
private:
    string _wall;
    string _window;
    string _door;
};

class HouseBuilder
{
public:
    virtual ~HouseBuilder() {}
    virtual void buildWall() = 0;
    virtual void buildWindow() = 0;
    virtual void buildDoor() = 0;
    virtual House *getHouse() = 0;
};

// 公寓构建者
class FlatBuilder : public HouseBuilder
{
public:
    FlatBuilder()
    {
        _house = new House;
    }

    ~FlatBuilder() 
    {  
        cout << "FlatBuilder 被析构" << endl;;
    }

public:
    virtual void buildWall()
    {
        _house->setWall("Flat wall");
    }

    virtual void buildWindow()
    {
        _house->setWindow("Flat window");
    }

    virtual void buildDoor()
    {
        _house->setDoor("Flat Door");
    }

    virtual House *getHouse()
    {
        return _house;
    }

private:
    House *_house;
};

// 别墅 构建者
class VillaBuilder : public HouseBuilder
{
public:
    VillaBuilder()
    {
        _house = new House;
    }

    ~VillaBuilder()
    {
        cout << "ViallBuilder 被析构" << endl;
    }

public:
    virtual void buildWall()
    {
        _house->setWall("Villa Wall");
    }

    virtual void buildWindow()
    {
        _house->setWindow("Villa Window");
    }

    virtual void buildDoor()
    {
        _house->setDoor("Villa Door");
    }

    virtual House *getHouse()
    {
        return _house;
    }

private:
    House *_house;
};

class Director
{
public:
    Director(HouseBuilder *builder)
    {
        _builder = builder;
    }
    ~Director()
    {
        cout << "Director 被析构" << endl;
    }

public:
    // 封装了房子的创建步骤
    void construct()
    {
        _builder->buildWall();  
        _builder->buildWindow();
        _builder->buildDoor();
    }
private:
    HouseBuilder *_builder;
};

void test()
{
    HouseBuilder *builder = NULL;
    Director *director = NULL;
    House *house = NULL;

    //建造公寓
    builder = new FlatBuilder;
    director = new Director(builder);
    director->construct();
    house = builder->getHouse();
    house->show();
    delete house;
    delete builder;
    delete director;

    // 建造别墅
    builder = new VillaBuilder;
    director = new Director(builder);
    director->construct();
    house = builder->getHouse();
    house->show();
    delete house;
    delete builder;
    delete director;
}

int main()
{
    test();
    cin.get();
    return 0;
}

参考:

http://www.cnblogs.com/cxjchen/p/3149897.html

http://www.2cto.com/kf/201603/492606.html