设计模式-建造者模式

建造者模式（Builder Pattern）

一个个build类和多个简单的类，build一步步的通过简单类来构建一个复杂的类。

1.   简淡的描述：

建造者模式通常解决创建复杂类这样一个问题。这样一个复杂的类通常由一些小的简单的类，通过一定的方法组合而成。这些简单类相对稳定，组合方法也相对稳定，唯一不稳定的是这个复杂类。

2.   引用一句话：

将变与不变分离开。

3.   与工厂模式的区别：

建造者模式更关注零配件的组装过程。即下面所讲的builder的内容。

 

Builder product director

Builder标示构造放法，派生自一个抽象接口。不同的builder决定了不同的产品。

Product是最终的产品，由不同的部分构成，具体包括哪些部分，如何构成，由builder决定；

Director负责使用不同的builder构造不同的产品

唯一抽象的是builder类，因为builder类代表了不同的构造方法。

4.   实例：

简单地说，汽车都是由发动机，底盘，车架，电控系统，座椅等组成，分别标记为engine， underpan， carframe，eleccontrol， seat。每个部分都可以看做是一个小的类。

虽然汽车都是由这些模块组成，但是不同的汽车所用的发动机，电控等不一定相同。这样，通过不同的生产线（builder）生产出不一样的汽车（product）。管理者（director）通过选择不同的生产线（builder）来生产不同的汽车。

5.   上代码：

//#include "vld.h"

#include <iostream>

#include <vector>

#include <string>

 

using namespace std;

//Product类

class car

{

public:

       car(){}

       virtual~car(){}

private:

       string engine;

       string underpan;

       string carframe;

       string eleccontrol;

       string seat;

public:

    void addEngine(const string part)

    {

       cout<<"add engine"<<endl;

              engine= part;

    }

       void addUnderpan(const string part)

    {

       cout<<"add underpan"<<endl;

              underpan= part;

    }

       void addCarframe(const string part)

    {

       cout<<"add carframe"<<endl;

              carframe= part;

    }

       void addEleccontrol(const string part)

       {

              cout<<"addeleccontrol"<<endl;

              eleccontrol= part;

       }

       void addSeat(const string part)

       {

              cout<<"addseat"<<endl;

              seat= part;

       }

 

    voidShow()const

    {

              cout<<"Thiscar has: "<<endl;

              cout<<"engine:"<<engine<<endl;

              cout<<"underpan:"<<underpan<<endl;

              cout<<"carframe:"<<carframe<<endl;

              cout<<"eleccontrol:"<<eleccontrol<<endl;

              cout<<"seat:"<<seat<<endl;

              cout<<"****************************"<<endl;

    }

};

 

//builder类，抽象类

class builder{

public:

       builder(){}

       virtual~builder(){}

public:

       virtualvoid installEngine() = 0;

       virtualvoid installUnderpan() = 0;

       virtualvoid installCarframe() = 0;

       virtualvoid installEleccontrol() = 0;

       virtualvoid installSeat() = 0;

       virtualcar getCar() = 0;

};

//具体的构造规则

class AcarBuilder: public builder

{

public:

       AcarBuilder(){}

       ~AcarBuilder(){}

public:

       void installEngine()

       {

              Acar.addEngine("Aengine");

       }

 

       void installUnderpan()

       {

              Acar.addUnderpan("Aunderpan");

       }

 

       void installCarframe()

       {

              Acar.addCarframe("Acarframe");

       }

 

       void installEleccontrol()

       {

              Acar.addEleccontrol("Aeleccontrol");

       }

 

       void installSeat()

       {

              Acar.addSeat("Aseat");

       }

 

 

       car getCar()

       {

              returnAcar;

       }

 

private:

       car Acar;

};

 

//Bcar is in the same way

//class Bcar;

 

 

//指导者，指导引用某一个构造方法（builder）

class Director

{

public:

    car Construct(builder &builder){

       builder.installEngine();

       builder.installUnderpan();

       builder.installCarframe();

       builder.installEleccontrol();

       builder.installSeat();

       return builder.getCar();

    }

 

private:

       car scar;

};

 

int main()

{

       cout<<"Blowis the procedure of build a car with builder pattern"<<endl;

  

       Directordirector;

       builder* acar = new AcarBuilder();

       car Acar = director.Construct(*acar);

       cout<<endl<<endl;

       Acar.Show();

       delete acar;//防止内存泄漏

}