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 _^_ ===