Builder Pattern

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

2.Builder模式结构图如下

3.实现

//main.cpp
#include "Builder.h"
#include "Product.h"
#include "Director.h"

#include <iostream>
using namespace std;

int main(int argc,char* argv[])
{
    Director* d = new Director(new ConcreteBuilder());

    d->Construct();

    return 0;  
}

#ifndef _PRODUCT_H_ 
#define _PRODUCT_H_
class Product 
{ 
public: 
    Product();
    ~Product();
    void ProducePart();
protected:
private:
};

class ProductPart 
{ 
public: 
    ProductPart();
    ~ProductPart();
    ProductPart* BuildPart();
protected:
private:
};

#endif

#include "Product.h" 
#include <iostream> 
using namespace std;

Product::Product() 
{ 
    ProducePart();
    cout<<"return a product"<<endl; 
}

Product::~Product() 
{

}
void Product::ProducePart() 
{ 
    cout<<"build part of product.."<<endl;
}

ProductPart::ProductPart() 
{ 
    //cout<<"build productpart.."<<endl; 
}
ProductPart::~ProductPart() 
{

}
ProductPart* ProductPart::BuildPart() 
{ 
    return new ProductPart; 
}

#ifndef _BUILDER_H_ 
#define _BUILDER_H_

#include <string> 
using namespace std;
class Product;

class Builder 
{ 
public: 
    virtual ~Builder();
    virtual void BuildPartA(const string& buildPara) = 0;
    virtual void BuildPartB(const string& buildPara) = 0;
    virtual void BuildPartC(const string& buildPara) = 0;
    virtual Product* GetProduct() = 0;
protected: 
    Builder();
private:
};

class ConcreteBuilder:public Builder 
{ 
public: 
    ConcreteBuilder();
    ~ConcreteBuilder();
    void BuildPartA(const string& buildPara);
    void BuildPartB(const string& buildPara);
    void BuildPartC(const string& buildPara);
    Product* GetProduct();
protected: 
private:
};

#endif

#include "Builder.h" 
#include "Product.h"
#include <iostream> 
using namespace std;

Builder::Builder() 
{

}
Builder::~Builder() 
{

}
ConcreteBuilder::ConcreteBuilder()
{

}
ConcreteBuilder::~ConcreteBuilder() 
{

}
void ConcreteBuilder::BuildPartA(const string& buildPara) 
{ 
    cout<<"Step1:Build PartA..."<<buildPara<<endl; 
}
void ConcreteBuilder::BuildPartB(const string& buildPara) 
{ 
    cout<<"Step1:Build PartB..."<<buildPara<<endl;
}
void ConcreteBuilder::BuildPartC(const string& buildPara) 
{ 
    cout<<"Step1:Build PartC..."<<buildPara<<endl; 
}
Product* ConcreteBuilder::GetProduct() 
{ 
    BuildPartA("pre-defined");
    BuildPartB("pre-defined");
    BuildPartC("pre-defined");
    return new Product(); 
}

#ifndef _DIRECTOR_H_ 
#define _DIRECTOR_H_
class Builder;

class Director 
{ 
public:
    Director(Builder* bld);
    ~Director();
    void Construct();
protected:
private: 
    Builder* _bld;
};
#endif

#include "director.h" 
#include "Builder.h"
Director::Director(Builder* bld) 
{ 
    _bld = bld;
}
Director::~Director() 
{

}
void Director::Construct()
{ 
    _bld->BuildPartA("user-defined"); 
    _bld->BuildPartB("user-defined"); 
    _bld->BuildPartC("user-defined"); 
}