设计模式学习：建造者模式

建造者模式将一个复杂对象的构建和他的表示分离，使得同样的构造过程可以创建不同的表示。

假设我们现在的产品是汉堡包，那么我们制作的过程永远是先加一片面包，加一片馅，再加一片面包。如果我是做牛肉堡，就是加的牛肉的馅，如果是做鸡肉堡，就是加的鸡肉的馅；但是者三个步骤是没得跑的。

那么这个时候，我们就可以使用建造者模式。

建造者模式有几个重要的角色。
builder：给出要给通用的接口，用来规范产品的各个组成成分。比如，要做一个汉堡包，就要包含两篇面包，一块馅。但是具体是什么样子的面包，什么样子的馅是不care的。
ConcreteBuilder：实现builder的接口。具体化各个部件的创建。建造完成之后，提供具体的产实例。比如我现在要做一个麦香鸡腿堡，就是加一个小麦面包，加一块鸡肉，加一个小麦面包。
Director：调用具体的构造者来创建复杂对象的各个部分，在Director中不涉及具体产品的信息，只负责保证对象各部分完整创建或者按照某种顺序创建。是建造者模式的重心。
Product：要创建的复杂对象。

建造者模式的代码实现：

// builder.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <vector>
#include <string>
#include <iostream>

using namespace std;

class Product
{
    vector<string> parts;
public:
    void Add(string part)
    {
        parts.push_back(part);
    }
    void show()
    {
        for (size_t i = 0; i < parts.size(); i++)
        {
            cout << parts[i] << endl;
        }
    }
};

class Builder
{
public:
    virtual void BuildDownBread() = 0;
    virtual void BuildPie() = 0;
    virtual void BuildUpBread() = 0;
    virtual Product GetProduct() = 0;
};

class ChickenBuilder: public Builder
{
private:
    Product product;
public:
    virtual void BuildDownBread()
    {
        product.Add("wheat bread");
    }
    virtual void BuildPie()
    {
        product.Add("chicken pie");
    }
    virtual void BuildUpBread()
    {
        product.Add("wheat bread");
    }
    virtual Product GetProduct()
    {
        return product;
    }
};

class BeefBuilder : public Builder
{
private:
    Product product;
public:
    virtual void BuildDownBread()
    {
        product.Add("normal bread");
    }
    virtual void BuildPie()
    {
        product.Add("beef pie");
    }
    virtual void BuildUpBread()
    {
        product.Add("normal bread");
    }
    virtual Product GetProduct()
    {
        return product;
    }
};

class Director
{
public:
    void construct(Builder &builder) // 知道构造过程
    {
        builder.BuildDownBread();
        builder.BuildPie();
        builder.BuildUpBread();
    }
};

int main()
{
    Director *director = new Director();    // 实例化一个指导者，只用一个指导者就可以指导各个builder建造具体的product

    Builder *chickenBuilder = new ChickenBuilder(); // 实例化一个鸡肉汉堡builder
    Builder *beefBuilder = new BeefBuilder();   // 实例化一个牛肉汉堡builder

    director->construct(*chickenBuilder);   // 做鸡肉汉堡产品
    director->construct(*beefBuilder);  // 做牛肉汉堡产品

    Product chickenHamburger = chickenBuilder->GetProduct(); // 返回一个鸡肉汉堡，实际上是返回一个鸡肉汉堡builder内产品的拷贝。这个产品的原型再调用direcotor的construct的时候得到。
    Product beefHamburger = beefBuilder->GetProduct(); // 返回一个牛肉汉堡
    chickenHamburger.show();
    beefHamburger.show();

    delete director;
    delete chickenBuilder;
    delete beefBuilder;


    system("pause");
    return 0;
}

实现一个猪肉汉堡的builder，已有的产品builder类，Product类，与director类都不需要变动。

一句话总结：
建造者模式将一个复杂对象的构建和他的表示分离，使得同样的构造过程可以创建不同的表示。其核心是Director，Director掌控了各个产品的建造过程。