建造者模式

建房子要怎么建？

　　首先要有一个包工头，即指挥者。为什么要请个包工头呢，因为包工头知道建房子的流程：首先打地基、然后建墙体，然后封顶，最后是装修。

　　除此之外，包工头还能根据客户的需求来盖不同类型的房子，比如普通楼房和别墅。

　　当然，少不了一批帮包工头干活的人，即建造者Builder。

用代码描述：

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

// 建筑队，打地基、筑墙、盖顶、装修都会
class Builder
{
public:
    virtual void DaDiJi ()=0;
    virtual void ZhuQiang ()=0;
    virtual void GaiDing ()=0;
    virtual void ZhuangXiu ()=0;
};
// 建楼房
Class LouFangBuilder : public Builder
{
public:
    virtual void DaDiJi ()
    {
        cout<<"楼房打地基"<<endl;
    }
    virtual void ZhuQiang ()
    {
        cout<<"楼房筑墙"<<endl;
    }
    virtual void GaiDing ()
    {
        cout<<"楼房盖顶"<<endl;
    }
    virtual void ZhuangXiu ()
    {
        cout<<"楼房装修"<<endl;
    }
};
// 建别墅
Class BieShuBuilder : public Builder
{
public:
    virtual void DaDiJi ()
    {
        cout<<"别墅打地基"<<endl;
    }
    virtual void ZhuQiang ()
    {
        cout<<"别墅筑墙"<<endl;
    }
    virtual void GaiDing ()
    {
        cout<<"别墅盖顶"<<endl;
    }
    virtual void ZhuangXiu ()
    {
        cout<<"别墅装修"<<endl;
    }
};

// 包工头
class Direct
{
private:
    // 包工头私有一个建筑队，只有包工头可以指挥。
    // 这个建筑队名称根据需求来定， 
    // 建楼房的时候叫楼房建筑队，建别墅的时候叫别墅建筑队
    Builder* builder;
public:
    // 包工头指挥建筑队建房：打地基、筑墙、盖顶、装修。
    void Construct(Builder * builder)
    {
        builder->DaDiJi();
        builder->ZhuQiang();
        builder->GaiDing();
        builder->ZhuangXiu();
    }
};

// 客户端
int main()
{
    // 指定包工头
    Direct *director = new Direct();
    // 建楼房还是别墅
    Builder *b1 = new LouFangBuilder();
    Builder *b2 = new BieShuBuilder();
    // 包工头指挥楼房建筑队建造楼房
    director->Construct(b1);
    return 0;
}

　　后来，房主说房子建好后我要检查，地基、墙体、房顶、装饰都要看看。包工头说好吧，那我就把地基、墙体、房顶、装饰作为四个装配部件，每完成一个过程，”产品“就装配一个部件，并提供展示的功能。交付产品的时候我就可以把所有部件给你看。

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

// 说干就干，房子作为我们的产品
class Product
{
    vector<string> parts;
public:
    // 每完成一个部件，”产品“就添加一个部件
    void Add(const string part)
    {
        parts.push_back(part);
    }
    // 展示产品的每一个部分
    void Show()const
    {
        for(int i = 0 ; i < parts.size() ; i++)
        {
            cout<<parts[i]<<endl;
        }
    }
};

// 建筑队，打地基、筑墙、盖顶、装修都会
class Builder
{
public:
    virtual void DaDiJi ()=0;
    virtual void ZhuQiang ()=0;
    virtual void GaiDing ()=0;
    virtual void ZhuangXiu ()=0;
    virtual Product GetResult() = 0; 
};
// 建楼房
class LouFangBuilder : public Builder
{
private:
    Product product; 
public:
    virtual void DaDiJi()
    {
        product.Add("楼房地基");   // 产品添加楼房地基部件
    }
    virtual void ZhuQiang()
    {
        product.Add("楼房墙体");   // 产品添加楼房墙体部件
    }
    virtual void GaiDing()
    {
        product.Add("楼房房顶");   // 产品添加楼房房顶部件
    }
    virtual void ZhuangXiu()
    {
        product.Add("楼房装饰");   // 产品添加楼房装饰部件
    }
    virtual Product GetResult()
    {
        return product;
    }
};
// 建别墅
class BieShuBuilder : public Builder
{
private:
    Product product;
public:
    virtual void DaDiJi()
    {
        product.Add("别墅地基");   // 产品添加别墅地基部件
    }
    virtual void ZhuQiang()
    {
        product.Add("别墅墙体");   // 产品添加别墅墙体部件
    }
    virtual void GaiDing()
    {
        product.Add("别墅房顶");   // 产品添加别墅房顶部件
    }
    virtual void ZhuangXiu()
    {
        product.Add("别墅装饰");   // 产品添加别墅装饰部件
    }
    virtual Product GetResult()
    {
        return product;
    }
};

// 包工头
class Direct
{
private:
    // 包工头私有一个建筑队，只有包工头可以指挥。
    // 这个建筑队名称根据需求来定， 
    // 建楼房的时候叫楼房建筑队，建别墅的时候叫别墅建筑队
    Builder* builder;
public:
    // 包工头指挥建筑队建房：打地基、筑墙、盖顶、装修。
    void Construct(Builder * builder)
    {
        builder->DaDiJi();
        builder->ZhuQiang();
        builder->GaiDing();
        builder->ZhuangXiu();
    }
};

int main()
{
    // 指定包工头
    Direct *director = new Direct();
    // 建楼房还是别墅
    Builder *b1 = new LouFangBuilder();
    Builder *b2 = new BieShuBuilder();
    // 包工头指挥楼房建筑队建造楼房
    director->Construct(b1);

    // 楼房建好了，包工头说，这就是我们的产品
    Product p1 = b1->GetResult();
    // 产品交付，包工头把地基、墙体、房顶、装饰每一个部分都展示给房主看。
    p1.Show(); 
    return 0;
}    

　　可以看到，不管加不加产品类，建房子的流程是不变的，即整个Direct类没做任何改变。这就引出了建造者模式的定义：将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示。就如同样的Construct可以创建楼房也可以创建别墅。

　　

　　建造者模式和工厂方法模式类似，我们将上面的第一个例子改造成工厂方法模式，看看他们的区别。

　　

　　色 部分为工厂方法模式

      色 部分为建造者模式。

#include <string>
#include <iostream>
#include <vector>
using namespace std;
// 建筑队
class CBuilder
{
public:
    virtual void DaDiJi ()=0;
    virtual void ZhuQiang ()=0;
    virtual void GaiDing ()=0;
    virtual void ZhuangXiu ()=0;
};
// 建楼房
class LouFangBuilder : public CBuilder
{
public:
    virtual void DaDiJi ()
    {
        cout<<"楼房打地基"<<endl;
    }
    virtual void ZhuQiang ()
    {
        cout<<"楼房筑墙"<<endl;
    }
    virtual void GaiDing ()
    {
        cout<<"楼房盖顶"<<endl;
    }
    virtual void ZhuangXiu ()
    {
        cout<<"楼房装修"<<endl;
    }
};
// 建别墅
class BieShuBuilder : public CBuilder
{
public:
    virtual void DaDiJi ()
    {
        cout<<"别墅打地基"<<endl;
    }
    virtual void ZhuQiang ()
    {
        cout<<"别墅筑墙"<<endl;
    }
    virtual void GaiDing ()
    {
        cout<<"别墅盖顶"<<endl;
    }
    virtual void ZhuangXiu ()
    {
        cout<<"别墅装修"<<endl;
    }
};

//工厂模式
class CFactory
{
public:
    virtual CBuilder* Construct() = 0;
};

class LouFangFactory: public CFactory
{
    CBuilder* Construct ()
    {
        return new LouFangBuilder();
    }
};
class BieShuFactory: public CFactory
{
    CBuilder* Construct ()
    {
        return new BieShuBuilder();
    }
};

// 建造者模式
class Direct
{
private:
    CBuilder* builder;
public:
    void Construct(CBuilder* temp)
    {
        builder->DaDiJi();
        builder->ZhuQiang();
        builder->GaiDing();
        builder->ZhuangXiu();
    }
};

int main()
{
    // 工厂模式
    CFactory* p = new LouFangFactory;
    CBuilder* opr = p->Construct();
    opr->DaDiJi();
    opr->ZhuQiang();
    opr->GaiDing();
    opr->ZhuangXiu();
    
    // 建造者模式
    Direct *director = new Direct();
    CBuilder *b1 = new LouFangBuilder();
    CBuilder *b2 = new BieShuBuilder();
    director->Construct(b1);

    return 0;
}

　　也就是说，工厂方法模式能生成不同的产品，也能将具体产品再分解成一个个零件，但调用的时候只能一个零件一个零件的造。

　　而建造者模式把造零件的过程放到了一起，当生产一个产品时，是作为整个产品生产出来，不需要一个零件一个零件的装配。

　　

　　不知道为什么总感觉建造者模式一点都不像创建型模式？

 

最后，贴一下建造者模式的角色：

　　1）builder：为创建一个产品对象的各个部件指定抽象接口。

　　2）ConcreteBuilder：实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示，并 提供一个检索产品的接口。

　　3）Director：构造一个使用Builder接口的对象。

　　4）Product：表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。