设计模式 生成器模式

1、AutoBuilder.h

#ifndef AUTOBUILDER_H
#define AUTOBUILDER_H

class AutoBuilder  //Builder，创建基类
{
public:
    AutoBuilder(){};
    virtual ~AutoBuilder(){};
    virtual void BuildEngine(){};    //创建发动机,两个子类都加以实现
    virtual void BuildWheel(){};    //创建车轮，两个子类都加以实现
    virtual void BuildNavigation(){};    //车载导航，两个子类中有则实现，没有则不用实现
};
#endif // AUTOBUILDER_H

2-1、director.h

#ifndef DIRECTOR_H
#define DIRECTOR_H

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

#include "AutoBuilder.h"

class Director //指导者

{
public:

    Director(AutoBuilder* pAutoBuilder); //组装过程，不管什么车都组装过程一样

};
#endif // DIRECTOR_H

2-2、director.cpp

#include "director.h"

Director::Director(AutoBuilder* pAutoBuilder)
{
    pAutoBuilder->BuildEngine();
    pAutoBuilder->BuildWheel();
    pAutoBuilder->BuildNavigation();
}

3-1、driverbuilder.h

#ifndef DRIVERBUILDER_H
#define DRIVERBUILDER_H

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

#include "AutoBuilder.h"
#include "drivercar.h"

class DriverBuilder : public AutoBuilder//创建骑车子类
{
public:
    DriverBuilder();
    ~DriverBuilder();
    void BuildEngine();
    void BuildWheel();
    void BuildNavigation();
    DriverCar* GetDriverCar();
protected:
    DriverCar* m_pCar;
};
#endif // DRIVERBUILDER_H

3-2、driverbuilder.cpp

#include "driverbuilder.h"
DriverBuilder::DriverBuilder()
    :m_pCar(new DriverCar)
{

}

DriverBuilder::~DriverBuilder()
{
    delete m_pCar;
}

void DriverBuilder::BuildEngine()
{
    cout << "DriverCar build engine" << endl;
}

void DriverBuilder:: BuildWheel()
{
    cout << "DriverCar build wheels" << endl;
}

void DriverBuilder:: BuildNavigation()
{
    cout << "DriverCar build navigation" << endl;
}

DriverCar*  DriverBuilder::GetDriverCar()
{
    return m_pCar;
}

4-1、drivercar.h

#ifndef DRIVERCAR_H
#define DRIVERCAR_H

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

class DriverCar  //product
{
public:
    void Driver();  //骑车用
};
#endif // DRIVERCAR_H

4-2、drivercar.cpp

#include "drivercar.h"

void DriverCar::Driver()
{
    cout << "Driver with DriverCar" << endl;
}

5-1、taxibuilder.h

#ifndef TAXIBUILDER_H
#define TAXIBUILDER_H

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

#include "AutoBuilder.h"
#include "taxicar.h"

class TaxiBuilder : public AutoBuilder//创建租车子类
{
public:
    TaxiBuilder();
    ~TaxiBuilder();
    void BuildEngine();
    void BuildWheel();
    TaxiCar* GetTaxiCar();
protected:
    TaxiCar* m_pCar;
};
#endif // TAXIBUILDER_H

5-2、taxibuilder.cpp

#include "taxibuilder.h"
#include "AutoBuilder.h"

TaxiBuilder::TaxiBuilder()
    :m_pCar(new TaxiCar)
{

}

TaxiBuilder:: ~TaxiBuilder()
{
    delete m_pCar;
}

void TaxiBuilder:: BuildEngine()
{
    cout << "TaxiCar build engine" << endl;
}

void TaxiBuilder:: BuildWheel()
{
    cout << "TaxiCar build wheels" << endl;
}

TaxiCar* TaxiBuilder:: GetTaxiCar()
{
    return m_pCar;
}

6-1、taxicar.h

#ifndef TAXICAR_H
#define TAXICAR_H

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

class TaxiCar  //product
{
public:
    void Taxi(); //租车用
};
#endif // TAXICAR_H

6-2、taxicar.cpp

#include "taxicar.h"

void TaxiCar::Taxi()
{
    cout << "Taxi with TaxiCar" << endl;
}

7、main.cpp

/*
开发IDE：qt creater
开发环境：QT C++
参考网站：神秘果：http://www.shenmiguo.com/

定义：
将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

理解：
1.生成器（Builder）模式是一步步构建一个复杂的产品，它允许用户可以只通过指定复杂对象的类型和内容就可以构建它们，
  用户不知道内部的具体构建细节。
2.Builder基类创建复杂产品（Product）全过程的抽象基类。Builder基类提供若干个构造部件（BuildPart）的方法
  （基类提供缺省实现）。具体构建产品的过程由ConcreteBuilder实现，GetResult()是获取构造完成后的对象
  （该方法并不在基类中！因为产品Product一般没有抽象基类。如果产品有抽象基类，GetResult就可以放在基类里）。
3.Director在构造函数中调用Builder的构造部件方法，当最后一个部件方法调用完成后，就产生了一个复杂的产品。
  Director的作用是封装一个产品的各个部件装配过程。
4.Builder基类将公共的部分提取出来，各个部件方法（BuildPart）由子类扩展实现。
5.Director中聚合了Builder基类指针，这样可以适应不同的具体构建者。

要点：
1.生成器模式将构建复杂对象的部件和构建过程（算法）解耦。生产一辆汽车的部件有车轮、发动机等等，装配一辆汽车的过程是很复杂的。
  应用Builder模式，生产部件（Builder.BuilderPart方法）和汽车装配过程（Director角色）是可以分开的。
2.生成器模式构建的对象，部件可以不同，但构建过程是一样的。不同品牌的汽车生产流程相同，但由于部件的差别导致品牌地位差异。
3.生成器模式与抽象工厂模式都是创建复杂对象，他们之间的差别比较：
  Builder模式强调的是一步步构建一个复杂的对象。Abstract Factory强调多个系列的产品对象，并不关注复杂性。
  Builder是生成若干个组件后，最后一步返回对象。Abstract Factory是立即返回对象的。

应用：
网络协议解析器的场景。譬如要对某种协议数据进行解析，数据解析过程包括获取协议类型、解密、解析包头、解析包体。
不管协议类型如何变化，解析的过程是不会变化的。解析这些数据的类就是生成器（Builder），包括解析包头等等方法。

源码中通过简单的汽车生产例子来说明生成器模式：创建一个骑车用的汽车和一个租车用的汽车

以上文字说明，从网上整理而来，有可能部分与其他同仁相同，请谅解，希望我们能够共同交流，谢谢！
*/

#include <QtCore/QCoreApplication>

#include "driverbuilder.h"
#include "taxibuilder.h"
#include "director.h"

int main(int argc, char *argv[])
{
    cout << "=== jhluroom start ========" << endl;

    DriverBuilder driverBuilder;
    Director d_driver(&driverBuilder); //我们不关心是如何组装的
    DriverCar* driverCar = driverBuilder.GetDriverCar();
    driverCar->Driver();

    TaxiBuilder taxiBuilder;
    Director d_taxi(&taxiBuilder);
    TaxiCar* taxiCar = taxiBuilder.GetTaxiCar();
    taxiCar->Taxi();

    cout << "=== jhluroom finish _^_ ===" << endl;
    
    return 0;
}

运行结果：
=== jhluroom start ========
DriverCar build engine
DriverCar build wheels
DriverCar build navigation
Driver with DriverCar
TaxiCar build engine
TaxiCar build wheels
Taxi with TaxiCar
=== jhluroom finish _^_ ===