建造者模式
Separate the construction of a complex object from its representation so that the same construction process can create different representations.
(将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。)
通用类图
产品类，实现模板方法模式，也就是模板方法和基本方法，如例子中的BenzModel和BWMModel
抽象建造者类，规范产品的组件，如例子中的CarModel
具体建造者类，继承抽象建造者类，依赖产品类。实现抽象类定义的所有方法，返回一个组建好的对象，如例子中的BenzBuilder和BWMBuilder
导演类，负责安排模块的顺序，和抽象建造者类是聚合关系。导演类起到封装的作用，避免高层模块深入到建造者内部的实现类。导演类可以有多个。
通用源代码
//产品类
class Product {
public:
void doSomething() {
//独立业务处理
}
};
//抽象建造者
class Builder {
public:
//设置产品的不同部分，以获得不同的产品
virtual void setPart() = 0;
//建造产品
virtual Product buildProduct() = 0;
};
//具体建造者
class ConcreteProduct : public Builder {
private:
Product product;
public:
void setPart() {
/*
*产品类内的逻辑处理
*/
}
//组建一个产品
Product buildProduct() {
return product;
}
};
//导演类
class Director {
private:
Builder builder;
public:
Product getAProduct() {
builder.setPart();
/*
*设置不同的零件，产生不同的产品
*/
return builder.buildProduct();
}
};
优点
封装性，客户端不必知道内部组成的细节，直接获得想要的对象
建造者独立，容易扩展
便于控制细节风险
使用场景
相同的方法，不同的执行顺序，产生不同的事件结果
多个部件或零件，可以转配到一个对象中，但是产生的运行结果不相同
产品类非常复杂，或者产品类中的调用顺序不同产生不同的效能
注意事项
建造者模式关注的是零件类型和装配工艺(顺序)，这是它与工厂方法模式最大不同的地方，虽然同为创建类模式，但是注重点不同
扩展
产品类可以使用模板方法模式来实现零件的组装，使得组装顺序不同对象效能也不同
建造者模式vs工厂模式，建造者模式最主要的功能是基本方法的调用顺序安排，也就是基本方法默认已经实现；工厂方法模式的重点是创建，不关系组装顺序。
示例代码
#include <iostream>
#include <list>
#include <string>
using namespace std;
class CarModel {
private:
list<string> msequence;
protected:
virtual void start() = 0;
virtual void stop() = 0;
virtual void alarm() = 0;
virtual void engineBoom() = 0;
public:
void run() {
for(auto s : msequence) {
if(s == "start") this->start();
else if(s == "stop") this->stop();
else if(s == "alarm") this->alarm();
else if(s == "engineBoom") this->engineBoom();
else cout << "undefined commend" << endl;
}
}
void setSequence(list<string> sequence) {
msequence = sequence;
}
};
class BenzModel : public CarModel {
protected:
virtual void start() {
cout << "BenzModel start" << endl;
}
virtual void stop() {
cout << "BenzModel stop" << endl;
}
virtual void alarm() {
cout << "BenzModel alarm" << endl;
}
virtual void engineBoom() {
cout << "BenzModel engineBoom" << endl;
}
};
class BWMModel : public CarModel {
protected:
virtual void start() {
cout << "BWMModel start" << endl;
}
virtual void stop() {
cout << "BWMModel stop" << endl;
}
virtual void alarm() {
cout << "BWMModel alarm" << endl;
}
virtual void engineBoom() {
cout << "BWMModel engineBoom" << endl;
}
};
class CarBuilder {
public:
virtual void setSequence(list<string> sequence) = 0;
virtual CarModel* getCarModel() = 0;
};
class BenzBuilder : public CarBuilder {
public:
virtual CarModel* getCarModel() {
return benz;
}
virtual void setSequence(list<string> sequence) {
benz->setSequence(sequence);
}
~BenzBuilder() {delete benz;}
private:
BenzModel *benz = new BenzModel();
};
class BWMBuilder : public CarBuilder {
public:
virtual CarModel* getCarModel() {
return bwm;
}
virtual void setSequence(list<string> sequence) {
bwm->setSequence(sequence);
}
~BWMBuilder() {delete bwm;}
private:
BWMModel* bwm = new BWMModel();
};
class Director {
private:
list<string> msequence;
BenzBuilder benzBuilder;
BWMBuilder bwmBuilder;
public:
BenzModel* getABenzModel() {
msequence.clear();
msequence.push_back("start");
msequence.push_back("stop");
benzBuilder.setSequence(msequence);
return dynamic_cast<BenzModel*>(benzBuilder.getCarModel());
}
BenzModel* getBBenzModel() {
msequence.clear();
msequence.push_back("engineBoom");
msequence.push_back("start");
msequence.push_back("stop");
benzBuilder.setSequence(msequence);
return dynamic_cast<BenzModel*>(benzBuilder.getCarModel());
}
BWMModel* getABWMModel() {
msequence.clear();
msequence.push_back("alarm");
msequence.push_back("start");
msequence.push_back("stop");
bwmBuilder.setSequence(msequence);
return dynamic_cast<BWMModel*>(bwmBuilder.getCarModel());
}
BWMModel* getBBWMModel() {
msequence.clear();
msequence.push_back("start");
bwmBuilder.setSequence(msequence);
return dynamic_cast<BWMModel*>(bwmBuilder.getCarModel());
}
};
int main() {
Director director;
BWMModel *bwm = director.getABWMModel();
bwm->run();
return 0;
}
