【设计模式】建造者(生成器)

生成器模式，也叫建造者模式。有人说后者是想强调该模式重点是强调建造过程，而不是生成。

个人比较认同，所以后文也叫建造者模式。

建造者模式，主要意图是将对象的建造于他的表示分离。从而使得同样的建造过程可以建造出不同的产品。

参与者有建造者，导演和具体的产品。

举例说明，我们想生产电脑，电脑就是产品。声明一个类，叫builder，而具体的建造者，需要继承自这个父类，并实现其构造方法，并最终返回构造后的产品。

这里变化的部分就是，不同的建造者和构造过程。建造者可以通过继承出新的类来实现扩展。

而建造过程，通过一个director类来封装。每个过程可以对应一个新的导演。导演负责调用具体建造者对应的建造方法。并最终获取其生产的产品。

/**
* @file test_builder.cpp
* @author itegel
* @date 2013/09/12 10:07:27
* @brief
*
**/

#include <iostream>
#include <string>
using namespace std;

class ComputerBuilder{
public:
ComputerBuilder(){}
virtual ~ComputerBuilder(){}
virtual void BuildBody(){
cout<<"no body!"<<endl;
}
virtual void BuildScreen(){
cout<<"no screen!"<<endl;
}
virtual void BuildMouse(){
cout<<"no mouse!"<<endl;
}
virtual void BuildKeybord(){
cout<<"no keybord!"<<endl;
}
virtual string GetResult() = 0;
};

class PCBuilder: public ComputerBuilder{
public:
PCBuilder(){
m_result = "A PC With: ";
}
virtual ~PCBuilder(){}
virtual void BuildBody(){
cout<<"PC body built!"<<endl;
m_result += "a Body; ";
}
virtual void BuildScreen(){
cout<<"PC screen built!"<<endl;
m_result += "a Screen; ";
}
virtual void BuildMouse(){
cout<<"PC mouse built!"<<endl;
m_result += "a Mouse; ";
}
virtual void BuildKeybord(){
cout<<"PC keybord built!"<<endl;
m_result += "a Keybord; ";
}
virtual string GetResult(){
return m_result;
}
private:
string m_result;
};

class IPadBuilder: public ComputerBuilder{
public:
IPadBuilder(){
m_result = "An Ipad With: ";
}
virtual ~IPadBuilder(){}
virtual void BuildBody(){
cout<<"IPad body built!"<<endl;
m_result += "a Body; ";
}
virtual void BuildScreen(){
cout<<"IPad screen built!"<<endl;
m_result += "a Screen; ";
}
virtual string GetResult(){
return m_result;
}
private:
string m_result;
};

class Director{
public:
Director(ComputerBuilder * computer_builder):m_computer_builder(computer_builder){}
virtual ~Director(){}
void ConstructComputer(){
m_computer_builder->BuildBody();
m_computer_builder->BuildScreen();
m_computer_builder->BuildMouse();
m_computer_builder->BuildKeybord();
cout<<"RESULT:"<<endl<<"\t"<<m_computer_builder->GetResult()<<endl;
}
private:
ComputerBuilder * m_computer_builder;
};

int main(){
cout<<"pc builder working..."<<endl;
ComputerBuilder * tmp_builder = new PCBuilder();
Director director1(tmp_builder);
director1.ConstructComputer();

cout<<endl<<"Ipad builder working..."<<endl;
ComputerBuilder * tmp_builder2 = new IPadBuilder();
Director director2(tmp_builder2);
director2.ConstructComputer();

return 0;
}

输出如下：

pc builder working...
PC body built!
PC screen built!
PC mouse built!
PC keybord built!
RESULT:
A PC With: a Body; a Screen; a Mouse; a Keybord;

Ipad builder working...
IPad body built!
IPad screen built!
no mouse!
no keybord!
RESULT:
An Ipad With: a Body; a Screen;

该模式，主要是分离了具体组装过程和每个过程的实现。适用于构造过程复杂，并且可以有多种建造方式的场景。建造过程和不同的建造方法很容易扩展。
缺点看起来是客户端需要知道有哪些建造者和建造过程。由客户端来选择具体的导演类和建造者。如果客户端不关注这些，那么就不适用了。

跟抽象工厂的区别是，抽象工厂强调多个系列产品兑现搞得构造方式，而建造者强调构造一个复杂对象的过程。