一：概念
Builder模式也叫建造者模式或者生成器模式，是由GoF提出的23种设计模式中的一种。Builder模式是一种对象创建型模式之一，用来隐藏复合对象的创建过程，它把复合对象的创建过程加以抽象，通过子类继承和重载的方式，动态地创建具有复合属性的对象。
对象的创建：Builder模式是为对象的创建而设计的模式
创建的是一个复合对象：被创建的对象为一个具有复合属性的复合对象
关注对象创建的各部分的创建过程：不同的工厂（这里指builder生成器）对产品属性有不同的创建方法。
二：动机
在软件系统中，有时候面临着“一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将他们组合在一起的算法却相对稳定。
如何应对这种变化？如何提供一种“封装机制”来隔离出“复杂对象的各个部分”的变化，从而保持系统中的“稳定构建算法”不随着需求改变而改变。
三：代码解析（建造房子）
class House{
//....
House(){ // 错误示例，不能这样写
this->BuildPart1(); // 构造函数中是静态绑定，此时调用纯虚函数会报错，不会去调用子类
for (int i = 0; i < 4; i++){
this->BuildPart2();
}
bool flag = pHouseBuilder->BuildPart3();
if (flag){
this->BuildPart4();
}
this->BuildPart5();
}
void Init(){ // 流程相对固定
this->BuildPart1(); // 构造第一部分
for (int i = 0; i < 4; i++){
this->BuildPart2();
}
bool flag = pHouseBuilder->BuildPart3();
if (flag){
this->BuildPart4();
}
this->BuildPart5();
}
virtual ~HouseBuilder(){}
protected:
virtual void BuildPart1() = 0;
virtual void BuildPart2() = 0;
virtual void BuildPart3() = 0;
virtual void BuildPart4() = 0;
virtual void BuildPart5() = 0;
};
C++构造函数中，是不会去调用子类的虚函数。
子类构造函数会先去调用父类构造函数，如果子类调用父类构造，父类构造中去寻找子类虚函数，会报错，因为子类构造函数还没有完成，子类虚函数先被调用，这违背对象的构造原理
class StoneHouse: public House{ //各种房子
protected:
virtual void BuildPart1(){
//pHouse->Part1 = ...;
}
virtual void BuildPart2(){
}
virtual void BuildPart3(){
}
virtual void BuildPart4(){
}
virtual void BuildPart5(){
}
};
四：模式定义
将一个复杂对象的构建与其表示相分离，使得同样的构建过程（稳定）可以创建不同的表示（变化）。
--《设计模式》Gof
Init就是同一个构建过程，而每一个对象我们只需要实现其构建步骤就可以创建不同的表示
int main()
{
House* pHouse = new StoneHouse();
pHouse->Init();
}
五：进一步优化（对象过于复杂，除了上面步骤还有其他方法和属性）
class House{ // 表示 抽象基类
//.... house 与 HouseBuilder 相分离
};
class HouseBuilder { // 构建 抽象基类
public:
House* GetResult(){
return pHouse;
}
virtual ~HouseBuilder(){}
protected:
House* pHouse;
virtual void BuildPart1()=0;
virtual void BuildPart2()=0;
virtual void BuildPart3()=0;
virtual void BuildPart4()=0;
virtual void BuildPart5()=0;
};
class StoneHouse: public House{
};
class StoneHouseBuilder: public HouseBuilder{
protected:
virtual void BuildPart1(){
//pHouse->Part1 = ...;
}
virtual void BuildPart2(){
}
virtual void BuildPart3(){
}
virtual void BuildPart4(){
}
virtual void BuildPart5(){
}
};
// 稳定
class HouseDirector{ // 同样的构建过程
public:
HouseBuilder* pHouseBuilder;
HouseDirector(HouseBuilder* pHouseBuilder){
this->pHouseBuilder=pHouseBuilder;
}
House* Construct(){
pHouseBuilder->BuildPart1();
for (int i = 0; i < 4; i++){
pHouseBuilder->BuildPart2();
}
bool flag=pHouseBuilder->BuildPart3();
if(flag){
pHouseBuilder->BuildPart4();
}
pHouseBuilder->BuildPart5();
return pHouseBuilder->GetResult();
}
};
HouseBuilder管构建，House将其分离出去，而创建步骤又是稳定的，我们再一步进行拆分为HouseDiretor,避免类的肥大
六：类图（结构）
七：要点总结
（一）Builder模式主要用于“分步骤构建一个复杂对象”。在这其中“分步骤”是一个稳定算法，而复杂对象的各个部分则经常变化。
（二）变化的点在哪里，封装哪里——Builder模式主要在于应对“复杂对象各个部分”的频繁需求变动。其缺点在于难以应对“分步骤构建算法”的需求变动。
（三）在Builder模式中，要注意不同语言中构造器内调用虚函数的差别（C++ vs. C#）。
八：构建器和工厂模式区别
（一）Factory模式中：
1.有一个抽象的工厂。
2.实现一个具体的工厂---汽车工厂。
3.工厂生产汽车A，得到汽车产品A。
4.工厂生产汽车B，得到汽车产品B。
（二）Builder模式:
1.离合器工厂生产离合器产品，得到汽车部件A。
2.轮胎工厂生产轮子产品，得到汽车部件B。
3.车身工厂生产车身产品，得到汽车部件C。
4.将这些部件放到一起，形成刚好能够组装成一辆汽车的整体。
5.将这个整体送到汽车组装工厂，得到一个汽车产品。
或者更抽象一点理解：
1.将汽车的每一个零件都送到汽车组装工厂。
2.在工厂里，组装离合器，得到汽车部件A。
3.在工厂里，组装轮胎，得到汽车部件B。
4.在工厂里，组装车身，得到汽车部件C。
5.在工厂里，组装每个部件，得到一个汽车产品。
这样做，目的是为了实现复杂对象生产线和其部件的解耦。
（三）二者不同在于：
Factory模式不考虑对象的组装过程，而直接生成一个我想要的对象。
Builder模式先一个个的创建对象的每一个部件，再统一组装成一个对象。
Factory模式所解决的问题是，工厂生产产品。而Builder模式所解决的问题是工厂控制产品生成器组装各个部件的过程，然后从产品生成器中得到产品。
九：案例实现（建房子）
（一）实现抽象类Director（工程师），House（房子），HouseBuilder（工程队）
class House
{
private:
string m_floor;
string m_wall;
string m_door;
public:
void setFloor(string floor)
{
this->m_floor = floor;
}
void setWall(string wall)
{
this->m_wall = wall;
}
void setDoor(string door)
{
this->m_door = door;
}
void getFloor()
{
cout << "install " << this->m_floor << endl;
}
void getWall()
{
cout << "install " << this->m_wall << endl;
}
void getDoor()
{
cout << "install " << this->m_door << endl;
}
};
class HouseBuilder
{
protected:
House* pHouse;
public:
virtual void BuildFloor() = 0;
virtual void BuildWall() = 0;
virtual void BuildDoor() = 0;
House* GetResult()
{
return pHouse;
}
};
class HouseDirector
{
public:
HouseBuilder* pHouseBuilder;
HouseDirector(HouseBuilder* pHouseBuilder)
{
this->pHouseBuilder = pHouseBuilder;
}
House* Construct()
{
pHouseBuilder->BuildWall();
pHouseBuilder->BuildFloor();
pHouseBuilder->BuildDoor();
return pHouseBuilder->GetResult();
}
};
（二）实现具体房子类和建造类
class StoneHouseBuilder :public HouseBuilder
{
public:
StoneHouseBuilder()
{
pHouse = new House();
}
virtual void BuildFloor()
{
pHouse->setFloor("stone floor");
}
virtual void BuildWall()
{
pHouse->setWall("stone wall");
}
virtual void BuildDoor()
{
pHouse->setDoor("stone door");
}
};
class FlatHouseBuilder :public HouseBuilder
{
public:
FlatHouseBuilder()
{
pHouse = new House();
}
virtual void BuildFloor()
{
pHouse->setFloor("flat floor");
}
virtual void BuildWall()
{
pHouse->setFloor("flat wall");
}
virtual void BuildDoor()
{
pHouse->setFloor("flat door");
}
};
（三）工程师步骤指挥，按步骤创建房屋
void main()
{
HouseBuilder* HB = new StoneHouseBuilder();
HouseDirector* HD = new HouseDirector(HB);
House* H = HD->Construct();
H->getWall();
H->getFloor();
H->getDoor();
delete H;
delete HB;
delete HD;
system("pause");
return;
}
