【重读设计模式】生成器模式

生成器模式也是一个较少使用的模式，因为和抽象工厂模式有点类似，导致了很多时候可以使用生成器最后却使用成了抽象工厂。这个模式说出来很容易理解，模式本身也很简单。下面一起熟悉一下。

定义：封装一个对象的构造过程，并允许按照步骤构造。

定义解释：我们将一个对象的生成按照某一种规则来定义，把这种规则的先后顺序称之为步骤，生成器模式会封装一个对象的构造步骤，该步骤是相对固定的，不能改变，指导者按照固定的步骤完成对象的构建。但是每个步骤中的行为是可变的，就好像造一个柜子，建造的步骤都是一样的，但是你可以选择款式、油漆颜色、木料种类一样。

使用场景：

（1）需要生成的对象有复杂的内部结构，也就是需要有很多的步骤来完成对象的构建。

（2）对象的构建需要固定的步骤，也就是有固定的行为和确定的顺序。

例子：

台式电脑的组装就是生成器模式的绝佳例子。一个电脑需要的被组装的配件是固定的，都需要cpu、主板、内存、硬盘、显示器、电源等。现在我需要去组装一台电脑，我会先去电脑装配城找一个配电脑的人。然后按照自己的要求在配购员的指导下完成装备的选择，配导员之后会将电脑组装起来成为一个可nnshe用的电脑给我们。在这里，电脑就是产品，配导员就是建造者，而买电脑的人就是指导者。

同时，我们知道配电脑的有很多家，每一家合作的配件都是固定的。也就是建造者是很多的，选择不同的建造者就得到了不同的电脑产品。

设计：

电脑在该例子中就是产品，我们定义为CComputer，由于其必须有的内容包括memory, harddisk, cpu, mainboard, power几个成员，由于其品牌和型号可选择，我们提供相应地设置函数用于设置其品牌和型号。导购在这里是建造者builder，我们定义为CBuilder，他提供了对CComputer的各个配件的设置方法，同时还给出了所有的配件都选好之后得到最终电脑信息。买电脑的人就是指导者，指导者指导建造器使用什么样的配件。

类图：

实现：

//============================================================================
// Name        : builder.cpp
// Author      : tester
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================


#include <iostream>
#include <stdio.h>
#include <string>
using namespace std;


class CComputer
{
public:
void set_cpu(const string& cpu)
{
m_cpuinfo = cpu;
}


void set_mem(const string& mem)
{
m_meminfo = mem;
}


void set_hd(const string& hd)
{
m_hdinfo = hd;
}


void set_pw(const string& pw)
{
m_pwinfo = pw;
}


void set_mb(const string& mb)
{
m_mbinfo = mb;
}


void get_cpu()
{
printf("cpu=%s\n", m_cpuinfo.c_str());
}


void get_mem()
{
printf("mem=%s\n", m_meminfo.c_str());
}


void get_hd()
{
printf("hd=%s\n", m_hdinfo.c_str());
}


void get_pw()
{
printf("pw=%s\n", m_pwinfo.c_str());
}


void get_mb()
{
printf("mb=%s\n", m_mbinfo.c_str());
}


void show()
{
printf("cpu=%s\n", m_cpuinfo.c_str());
printf("mem=%s\n", m_meminfo.c_str());
printf("hd=%s\n", m_hdinfo.c_str());
printf("pw=%s\n", m_pwinfo.c_str());
printf("mb=%s\n", m_mbinfo.c_str());
}


private:
string m_cpuinfo;
string m_meminfo;
string m_hdinfo;
string m_pwinfo;
string m_mbinfo;
};


class CBuilder
{
public:
virtual ~CBuilder(){};
virtual void set_cpu(const string& type) = 0;
virtual void set_mem(const string& type) = 0;
virtual void set_hd(const string& type) = 0;
virtual void set_pw(const string& type) = 0;
virtual void set_mb(const string& type) = 0;


virtual CComputer* get_computer() = 0;


protected:
CComputer* m_computer;
};


class CBuilderA : public CBuilder
{
public:
CBuilderA()
{
m_computer = new CComputer;
}
void set_cpu(const string& type)
{
m_computer->set_cpu(type + " SANSUNG");
}


void set_mem(const string& type)
{
m_computer->set_mem(type + " NOVDA");
}


void set_hd(const string& type)
{
m_computer->set_hd(type + " FOXCOM");
}


void set_pw(const string& type)
{
m_computer->set_pw(type + " FOXCOM");
}


void set_mb(const string& type)
{
m_computer->set_mb(type + " FOXCOM");
}


CComputer* get_computer()
{
return m_computer;
}
};


class CDirecter
{
public:
CDirecter(CBuilder* builder)
{
m_builder = builder;
}


CComputer* construct()
{
m_builder->set_cpu("IG120 2G");
m_builder->set_mem("TEX300 4G");
m_builder->set_hd("340I 500G");
m_builder->set_pw("YUEX");
m_builder->set_mb("YTH");


return m_builder->get_computer();
}


private:
CBuilder* m_builder;
};


int main() {
cout << "!!!Hello World!!!" << endl; // prints !!!Hello World!!!


CBuilder* builder = new CBuilderA;
CDirecter* directer = new CDirecter(builder);


CComputer* computer = directer->construct();
computer->show();


return 0;
}

结果：

!!!Hello World!!!
cpu=IG120 2G SANSUNG
mem=TEX300 4G NOVDA
hd=340I 500G FOXCOM
pw=YUEX FOXCOM
mb=YTH FOXCOM

总结：生成器模式将实现和构建分开，通过建造器将对象的构建过程抽象，这样就降低了对象本身的构建复杂度。另外一方面，和抽象工厂模式的区别必须要理解清楚，生成器模式适用的场景是将对象的各个部分单独构建出来，每次构建的是这个对象的某个部分，而抽象工厂是一次性构建所有的产品组。抽象工厂面向的是更高级的对象，而生成器是比较低级的内部部分。