设计模式之Builder模式

设计模式之Builder模式

1.介绍

          Builder模式:当我们要创建的对象很复杂的时候,我们要将复杂对象的创建过程和这个对象的表示分离开来,这样做的好处就是通过一步步的进行复杂对象的构建，由于在每一步构造过程中可以引入参数，使得经过相同步骤创建最后得到的对象展示不一样.

2.实例代码

//Product.h

class Product
{
public:
	Product();
	~Product();

	void ProducePart();
protected:
private:
};

class ProdectPart
{
public:
	ProductPart();
	~ProductPart();

	ProdectPart* BuildPart();
protected:
private:
};

//Product.cpp

#include "Component.h"

Component::Component()
{

}

Component::~Component()
{

}

void Component::Add(const Component&com)
{

}

Component* Component::GetChild(int index)
{
	return 0;
}

void Component::Remove(const Component& com)
{

}

//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;
protected:
	Builder();
private:
};

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

//Builder.cpp
#include “Builder.h”
#include “Product.h”
#include <iostream>
using namespace std;
Builder::Builder()
{
}

Builder::～Builder()
{
}

ConcreteBuilder::ConcreteBuilder()
{
}

ConcreteBuilder::～ConcreteBuilder()
{
}

void ConcreteBuilder::BuilderPatA(const string& buildPara)
{
	cout<<“Step1:Build PartA..”<<buildPara<<endl;
}

void ConcreteBuilder::BuilderPartB(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();
}

//Director.h

class Builder;
class Director
{
public:
	Director(Builder* bld);
	～Director();
	void Construct();
protectd:
private:
	Builder* _bld;
};


//Director.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(int agrc,char* argv[])
{
	Director* d=new Director(new ConcreteBuilder());
	d->Construct();
	return 0;
}

3.结果
  Builder模式代码中，BuildPart的参数是通过客户程序员引入的，用“user-deinded”代替，实际是在Construct方法中传入了这3个参数，
这样就可以得到不同的细微差别的复杂对象了。