Builder模式

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

product.h：

#ifndef _PRODUCT_H_
#define _PRODUCT_H_


class Product{
public:
	Product();
	~Product();
	void ProducePart();
};

class ProducePart{
public:
	ProducePart();
	~ProducePart();
	ProducePart* BuilPart();
};
#endif

product.cpp：

#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;
}

ProducePart::ProducePart(){

}

ProducePart::~ProducePart(){

}

ProducePart* ProducePart::BuilPart(){
	return new ProducePart();
}

Builder.h：

#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();
};

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

builder.cpp：

#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();
}

direct.h：

#ifndef _DIRECTOR_H_
#define _DIRECTOR_H_

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

direct.cpp：

#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");
}

main.cpp：

#include "builder.h"
#include "product.h"
#include "director.h"

#include <iostream>
using namespace std;


int main(){
	Director* d=new Director(new ConcreteBuilder());

	d->Construct();
	return 1;
}

Builder模式和AbstractFactory模式在功能上很相似，都是用来创建大的复杂的对象，区别在于：Builder强调的是一步步创建对象，并通过相同的创建过程获得不同的结果对象，一般来说Builder模式中对象不是直接返回的。而在AbstractFactory模式中对象时直接返回的，AbstractFactory模式强调的是创建多个相互依赖的对象提供同一的接口。