设计模式 生成器模式

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++
参考网站：神秘果：

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

理解：
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 _^_ ===