设计模式之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个参数,
这样就可以得到不同的细微差别的复杂对象了。