建造者模式
在gof的《设计模式 可复用面向对象软件的基础》中是这样说的：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
这句话，似懂非懂的。一个复杂对象的创建，其通常是由很多的子对象构成；如果一个对象能够直接就创建好了，那么也不会称之为复杂对象。由于项目中需求的变化，这个复杂对象的各个部分经常会发生剧烈的变化，但是，不管怎么变化，将它们组合在一起，组成一个复杂的对象的事实是不会变的。建造者模式就提供了一种“封装机制”来将各个对象的变化隔离开，最终，组合成复杂对象的过程是不会变的。
在《大话设计模式》一书中，例举了一个很好的例子————建造小人。建造一个小人，要分为六步：头部、身体、左手、右手、左脚和右脚。与抽象工厂模式不同的是，建造者模式是在director的控制下一步一步的构造出来的，在建造的过程中，建造者模式可以进行更精细的控制。不管人的头部、身体、左手、右手、左脚或者右脚如何变化，但是最终还是由这几部分组合在一起形成一个人，虽然是同一个建造过程，但是这个人就会有不同的表示，比如，胖子，瘦子，个高的，个低的等等。
uml图
类图如下：
时序图如下：
代码实现
/*
** filename : builderpattern
** description : more information, please go to https://www.coonote.com
*/
#include
using namespace std;
typedef enum mantypetag
{
kfatman,
kthinman,
knormal
}mantype;
class man
{
public:
void sethead(mantype type){
m_type = type; }
void setbody(mantype type){
m_type = type; }
void setlefthand(mantype type){
m_type = type; }
void setrighthand(mantype type){
m_type = type; }
void setleftfoot(mantype type){
m_type = type; }
void setrightfoot(mantype type){
m_type = type; }
void showman()
{
switch (m_type)
{
case kfatman:
cout<<"i'm a fat man"<sethead(kfatman); }
void buildbody(){
m_fatman->setbody(kfatman); }
void buildlefthand(){
m_fatman->setlefthand(kfatman); }
void buildrighthand(){
m_fatman->setrighthand(kfatman); }
void buildleftfoot(){
m_fatman->setleftfoot(kfatman); }
void buildrightfoot(){
m_fatman->setrightfoot(kfatman); }
man *getman(){
return m_fatman; }
private:
man *m_fatman;
};
// thismanbuilder
class thinmanbuilder : public builder
{
public:
thinmanbuilder(){
m_thinman = new man(); }
void buildhead(){
m_thinman->sethead(kthinman); }
void buildbody(){
m_thinman->setbody(kthinman); }
void buildlefthand(){
m_thinman->setlefthand(kthinman); }
void buildrighthand(){
m_thinman->setrighthand(kthinman); }
void buildleftfoot(){
m_thinman->setleftfoot(kthinman); }
void buildrightfoot(){
m_thinman->setrightfoot(kthinman); }
man *getman(){
return m_thinman; }
private:
man *m_thinman;
};
// director
class director
{
public:
director(builder *builder) {
m_builder = builder; }
void createman();
private:
builder *m_builder;
};
void director::createman()
{
m_builder->buildhead();
m_builder->buildbody();
m_builder->buildlefthand();
m_builder->buildrighthand();
m_builder->buildlefthand();
m_builder->buildrighthand();
}
int main(int argc, char *argv[])
{
builder *builderobj = new fatmanbuilder();
director directorobj(builderobj);
directorobj.createman();
man *manobj = builderobj->getman();
if (manobj == null)
return 0;
manobj->showman();
delete manobj; // 感谢张小张同学的review
manobj = null;
delete builderobj;
builderobj = null;
return 0;
}; 上面这个例子比较杂，但是也是建造者模式的应用。下面这个例子是建造者最一般，最简单的实现方法：
/*
** filename : builderpattern
** description : more information, please go to https://www.coonote.com
*/
#include
#include
using namespace std;
class builder;
// product
class product
{
public:
void addpart(const char *info) {
m_partinfovec.push_back(info); }
void showproduct()
{
for (std::vector::iterator item = m_partinfovec.begin();
item != m_partinfovec.end(); item)
{
cout<<*item< m_partinfovec;
};
// builder
class builder
{
public:
virtual void buildparta() {}
virtual void buildpartb() {}
virtual product *getproduct() {
return null; }
};
// concretebuilder
class concretebuilder : public builder
{
public:
concretebuilder() {
m_product = new product(); }
void buildparta()
{
m_product->addpart("parta completed");
}
void buildpartb()
{
m_product->addpart("partb completed");
}
product *getproduct() {
return m_product; }
private:
product *m_product;
};
// director
class director
{
public:
director(builder *builder) {
m_builder = builder; }
void createproduct()
{
m_builder->buildparta();
m_builder->buildpartb();
}
private:
builder *m_builder;
};
// main
int main()
{
builder *builderobj = new concretebuilder();
director directorobj(builderobj);
directorobj.createproduct();
product *productobj = builderobj->getproduct();
if (productobj == null)
{
return 0;
}
productobj->showproduct();
delete productobj;
productobj = null; // 谢谢宾零同学的review
delete builderobj;
builderobj = null;
} 通过比较上面的两个例子，可以很容易的把建造者模式的骨架抽象出来。
使用要点
- 建造者模式生成的对象有复杂的内部结构，将分步骤的去构建一个复杂的对象，分多少步是确定的，而每一步的实现是不同的，可能经常发生变化；
- 在上面的例子中，我们都看到了最终生成的man和product都没有抽象类，这又导出建造者适用的一种情况，当需要创建复杂对象的过程中，复杂对象没有多少共同的特点，很难抽象出来时，而复杂对象的组装又有一定的相似点时，建造者模式就可以发挥出作用。简单的说，可能使用了建造者模式，最终建造的对象可能没有多大的关系，关于这一点，阅读《设计模式 可复用面向对象软件的基础》中的建造者模式时是最有体会的。
总结
一个复杂对象是由多个部件组成的，建造者模式是把复杂对象的创建和部件的创建分别开来，分别用builder类和director类来表示。用director构建最后的复杂对象，而在上面builder接口中封装的是如何创建一个个部件（复杂对象是由这些部件组成的），也就是说，director负责如何将部件最后组装成产品。这样建造者模式就让设计和实现解耦了。
刚开始接触建造者模式的时候，最容易把建造者和抽象工厂模式混淆了。由于而这都属于创建型的设计模式，所以二者之间是有公共点的，但是建造者模式注重于对象组合，即不同的小对象组成一个整体的复杂大对象，而抽象工厂模式针对于接口编程，只是对外提供创建对象的工厂接口，不负责对象之后的处理。
建造者模式，是一个比较复杂，不容易权衡的设计模式。大家应该更多的阅读开源代码，理解他人是如何使用该模式的。从实际的应用中学习设计模式。