大胖的部落格

一个复杂对象的创建包括两个部分：每个部分的创建和按照一定的算法将它们组合起来。
如果对象需要扩展，组成对象的每个部分（内部表示）可能不一样，但将它们组合起来的算法（生产过程）可能是相同的。
将生产过程分离出来，封装在Direcotr类中；内部表示封装在Builder类中。
这样一个复杂对象的创建就分成了不变的生产过程（Director）和可扩展的内部表示（Builder）两部分。

如下示例中，Builder基类里的BuildPart方法不是纯虚函数，是因为有些时候子类并不一定要创建某个part，所以这里父类提供缺省实现。

#include <iostream>

using namespace std;

//复杂的产品，包括很多部分
class Product
{
public:
    Product(){cout<<"Product Construct"<<endl;}
    void PartA(){cout<<"build part A"<<endl;}
    void PartB(){cout<<"build part B"<<endl;}
    virtual ~Product(){cout<<"Product Destruct"<<endl;}
};

//Builder基类，负责具体创建产品的每个部分
class Builder
{
public:
    virtual void CreateProduct() = 0;
    virtual void BuildPartA(){}
    virtual void BuildPartB(){}
    virtual Product* GetProduct() = 0;
};

//具体builder类
class ConcreteBuilder: public Builder
{
public:
    void CreateProduct()
    {
        p = new Product;
    }
    void BuildPartA()
    {
        p->PartA();
    }
    void BuildPartB()
    {
        p->PartB();
    }
    Product* GetProduct(){return p;}
private:
    Product *p;
};

//组装产品的Director类，负责对Builder生产的每个部件进行组装
class Director
{
public:
    void Construct(Builder* pb)
    {
        pb->CreateProduct();
        pb->BuildPartA();
        pb->BuildPartB();
    }
};

int main()
{
    //创建director和builder
    Director* pd = new Director;
    Builder* pb = new ConcreteBuilder;
    //创造产品
    pd->Construct(pb);
    Product* pp = pb->GetProduct();
    delete pp;
    delete pb;
    delete pd;

    return 0;
}