设计模式之建造者模式(生成器模式)(Builder) 创建型模式

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

例如汽车的生产过程:

Builder模式中:

1.离合器工厂生产离合器产品,得到汽车部件A.

2.轮胎工厂生产轮子产品,得到汽车部件B.

3.车声工厂生产车声产品,得到汽车部件C.

4.将这些部件放到一起,形成刚好能够组装成一辆汽车的整体.

5.将这个整体送到汽车组装工厂,得到一个产品汽车.

Factor模式中:

1.有一个抽象的工厂.

2.实现一个具体的工厂----汽车工厂.

3.工厂生产汽车A,得到汽车产品A.

4.工厂生产汽车B,得到汽车产品B.

二者不同在于:

Factor模式不考虑对象的组装过程,而是直接生成一个我想要的对象.

Builder模式先一个个的创建每一个部件,再统一组装成一个对象.

Factor模式所解决的问题是,工厂生产产品.而Builder模式所解决的问题是工厂控制产品生成器组装各个部件的过程,然后从产品生成器中得到产品.

Builder模式和AbstractFactory模式在功能上很相似,因为都是用例创建大的复杂的对象,他们的区别是:Builder模式是强调一步步创建对象,并通过相同的创建过程可以获得不同的结果对象,一般来说Builder模式中对象不是直接返回的.而在AbstractFactory模式中对象是直接返回的,AbstractFactory模式强调的是为创建多个相互依赖的对象提供一个同一的接口.

------------------------------------------Builder.h-----------------------------------------------------

#ifndef BUILDER_H_

#define BUILDER_H_

//虚拟基类,是所有Builder的基类,提供不同部分的构建接口函数

class Builder

{

public:

Builder()

{};

virtual ~Builder()

{}

//纯虚函数,提供构建不同部分的构建接口函数

virtual void BuilderPartA() = 0;

virtual void BuilderPartB() = 0;

};

//使用Builder构建产品,构建产品的过程都一致,当时不同的Builder有不同的实现

//这个不同的实现通过不同的Builder派生类来实现,存有一个Builder的指针,通过这个来实现多太调用

class Director

{

public:

Director(Builder * pBuilder);

~Director();

void Construct();

private:

Builder *m_pBuilder;

}

//Builder的派生类,实现BuilderPartA和BuilderPartB接口函数

class ConcreteBuilder1:public B uilder

{

public:

ConcreteBuilder1()

{}

virtual ~ConcreteBuilder1()

{}

virtual void BuilderPartA();

virtual void BuilderPartB();

};

//Builder的派生类,实现BuilderPartA和BuilderPartB接口函数

class ConcreteBuilder2:public Builder

{

public:

ConcreteBuilder2()

{}

virtual ~ConcreteBuilder2()

{}

virtual void BuilderPartA();

virtual void BuilderPartB();

};

#endif

------------------------------------Builder.cpp-----------------------------------

#include "Builder.h"

#include <iostream>

void ConcreteBuilder1::BuilderPartA()

{

std::cout <<"BuilderPartA by ConcreteBuilder1"<<endl;

}

void ConcreteBuilder1::BuilderPartB()

{

std::cout<<"BuilderPartB by ConcreteBuilder1"<<endl;

}

void ConcreteBuilder2::BuilderPartA

{

std::cout<<"BuilderPartA by ConcreteBuilder2"<<endl;

}

void ConcreteBuilder2::BuilderPartB

{

std::cout<<"BuilderPartB by ConcreteBuilder2"<<endl;

}

Director::Direcotr(Builder *pBuilder):m_pBuilder(pBuilder)

{}

Direcotr::~Director()

{

delete m_pBuilder;

m_pBuilder = NULL;

}

//Construct函数表示一个对象的整个构造过程,不同的部分之间的装配方式都是一致的

void Direcotr::Construct()

{

m_pBuilder->BuilderPartA();

m_PBuilder->BuilderPartB();

}

-------------------------------------main.cpp-------------------------

#include "Builder.h"

#include<stdlib.h>

int main()

{

Builder *pBuilder1 = new ConcreteBuilder1;

Direcotr *pDictor1 = new Director(pBuilder1);

pDirector1->Construct();

Builder *pBuilder2 = new ConcreteBuilder2;

Director *pDirector2 = new Director(pBuilder2);

pDirecotr2->Construct();

delete pDirector1;

delete pDirector2;

return 0;

}