设计模式学习笔记：Builder（创建者）

创建者（Builder）模式是一种对象创建模式，意图是将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

适用场景

1） 当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。

2） 当构造过程必须允许被构造的对象有不同的表示时。

模式结构





参与者与类之间协作

B u i l d e r，如代码中的

为创建一个P r o d u c t对象的各个部件指定抽象接口。

C o n c r e t e B u i l d e r

实现B u i l d e r的接口以构造和装配该产品的各个部件。

定义并明确它所创建的表示。

提供一个检索产品的接口。

Director

构造一个使用B u i l d e r接口的对象。

P r o d u c t

表示被构造的复杂对象。C o n c r e t e B u i l d e r创建该产品的内部表示并定义它的装配过程。

包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

实现

首先是头文件的声明

//decalretion of classes
#ifndef TABLETPC
#define TABLETPC

#include <iostream>
using std::string;

//平板电脑的简单抽象，包含芯片，内存，输入感应器，触摸屏等,相当于Product
class TabletPC
{
public:
void SetChip(string chip);
void SetMemory(string memory);
void SetSensor(string sensor);
void SetScreen(string screen);

string GetChip();
string GetMemory();
string GetSensor();
string GetScreen();
private:
string m_chip;              //芯片
string m_memory;            //内存
string m_iSensor;           //输入感应器
string m_tScreen;           //触摸屏
};

//平板电脑Builder类，相当于结构模式图中的Builder
class TabletPCBuilder
{
public:
virtual void MakeChip() = 0;
virtual void MakeMemory() = 0;
virtual void MakeInputSensor() = 0;
virtual void MakeTouchScreen() = 0;
public:
virtual TabletPC GetTabletPC() = 0;
};

//具体的Builder
class AndroidBuilder:public TabletPCBuilder
{
private:
TabletPC m_tabletPC;
public:
void MakeChip();
void MakeMemory();
void MakeInputSensor();
void MakeTouchScreen();
public:
TabletPC GetTabletPC();
};

class TabletDirector
{
public:
void MakeTabletPC(TabletPCBuilder &builder);
};
#endif

然后是部分实现：

//TabletPC.cpp
#include "TabletPC.h"

//Tablet类的实现
void TabletPC::SetChip(string chip)
{
m_chip = chip;
}

string TabletPC::GetChip()
{
return m_chip;
}

void TabletPC::SetMemory(string memory)
{
m_memory = memory;
}

string TabletPC::GetMemory()
{
return m_memory;
}

void TabletPC::SetScreen(string screen)
{
m_tScreen = screen;
}

string TabletPC::GetScreen()
{
return m_tScreen;
}

void TabletPC::SetSensor(string sensor)
{
m_iSensor = sensor;
}

string TabletPC::GetSensor()
{
return m_iSensor;
}

void AndroidBuilder::MakeChip()
{
m_tabletPC.SetChip("ARM+DSP-android");
}

void AndroidBuilder::MakeInputSensor()
{
m_tabletPC.SetSensor("sensor-android");
}

void AndroidBuilder::MakeMemory()
{
m_tabletPC.SetMemory("memory-android");
}

void AndroidBuilder::MakeTouchScreen()
{
m_tabletPC.SetScreen("screen-android");
}

TabletPC AndroidBuilder::GetTabletPC()
{
return m_tabletPC;
}

void TabletDirector::MakeTabletPC(TabletPCBuilder &builder)
{
builder.MakeChip();
builder.MakeInputSensor();
builder.MakeMemory();
builder.MakeTouchScreen();
}

最后是测试代码（可以理解为模式结构图中的Client）：

//client--main
#include "TabletPC.h"
#include <string>

using namespace std;

int main()
{
AndroidBuilder builder;
TabletDirector director;
director.MakeTabletPC(builder);
TabletPC tPC = builder.GetTabletPC();

cout << tPC.GetChip() << endl;
cout << tPC.GetMemory() << endl;
cout << tPC.GetScreen() << endl;
cout << tPC.GetSensor() << endl;

char ch = getchar();
return 1;
}

以下是测试截图：



取得的效果

1 ) 它使你可以改变一个产品的内部表示B u i l d e r对象提供给导向器一个构造产品的抽象接口。该接口使得生成器可以隐藏这个产品的表示和内部结构。它同时也隐藏了该产品是如何装配的。因为产品是通过抽象接口构造的，你在改变该产品的内部表示时所要做的只是定义一个新的生成器。

2) 它将构造代码和表示代码分开B u i l d e r模式通过封装一个复杂对象的创建和表示方式提高了对象的模块性。客户不需要知道定义产品内部结构的类的所有信息；这些类是不出现在B u i l d e r接口中的。每个C o n c r e t e B u i l d e r包含了创建和装配一个特定产品的所有代码。这些代码只需要写一次；然后不同的D i r e c t o r可以复用它以在相同部件集合的基础上构作不同的P r o d u c t。

3 ) 可对构造过程进行更精细的控制B u i l d e r模式与一下子就生成产品的创建型模式不同，它是在导向者的控制下一步一步构造产品的。仅当该产品完成时导向者才从生成器中取回它。因此B u i l d e r接口相比其他创建型模式能更好的反映产品的构造过程。这使你可以更精细的控制构建过程，从而能更精细的控制所得产品的内部结构