以下内容均来自GeekBand极客班C++ 设计模式课程（李建忠老师主讲）
Builder
“对象创建”模型
通过“对象创建”模式绕开new，避免对象创建（new）过程中所导致的紧耦合（依赖具体类），从而支持对象创建的稳定。它是接口抽象之后的第一步工作。
典型模式
Factory Method
Abstract Factory
Prototype
Builder
动机（Motivation）
在软件系统中，有时候面临着“一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定（这段描述和Template Method非常接近）
如何应对这种变化？如何提供一种“封装机制”来隔离出“复杂对象的各个部分”的变化，从而保持系统中的“稳定构造算法”不随着需求改变而改变？
《设计模式》GOF的定义：
将一个复杂对象的构建与其表示相分离，使得同样的构建过程（稳定）可以创建不同的表示（变化）
示例
当前有一个造房子的类
-
class House{
-
public:
-
void Init(){
-
this->BuildPart1();
-
for(
int i =
0; i<
4 ; i++){
-
this->BuildPart2();
-
}
-
-
bool flag =
this->BuildPart3();
-
-
if(flag){
-
this->BuildPart4();
-
}
-
this->BuildPart5();
-
}
-
virtual ~House(){}
-
protected:
-
virtual void BuildPart1() =
0;
-
virtual void BuildPart2() =
0;
-
virtual void BuildPart3() =
0;
-
virtual void BuildPart4() =
0;
-
virtual void BuildPart5() =
0;
-
};
有一个整体流程，某些步骤的具体实现是要下放到子类中进行实现的
形式和Template Method十分相似，但是重点在去构造，创建一个对象的时候就要执行
那么能不能直接写成下面这种形式：
-
House(){
-
this->BuildPart1();
-
for(
int i =
0; i<
4 ; i++){
-
this->BuildPart2();
-
}
-
-
bool flag =
this->BuildPart3();
-
-
if(flag){
-
this->BuildPart4();
-
}
-
this->BuildPart5();
-
}
实际上是不行的，构造函数里面调用的函数都是静态编联。
因为在C++中，一个对象先要调用构造器，然后才能存在，而子类构造函数执行前是要调用父类构造函数的。
如果想在构造函数里面动态编联，基本是不可能的。
但是现在由需要在对象创造的时候完成这些工作，那么就要使用Builder模式，单独在Init函数中书写这些过程
比如现在要盖一个石头房子
-
class StoneHouse :
public House{
-
public:
-
virtual void BuildPart1(){
-
-
}
-
virtual void BuildPart2(){
-
-
}
-
virtual void BuildPart3(){
-
-
}
-
virtual void BuildPart4(){
-
-
}
-
virtual void BuildPart5(){
-
-
}
-
-
};
只需要继承并且实现这些具体步骤即可。
主函数中的具体应用过程。
-
int main(){
-
House * pHouse =
new StoneHouse();
-
pHouse->Init();
-
}
但是如果这个构建过程过于复杂，更具重构原理，直接将这个构建过程单独提取出来，放在一个类中。
并将固定不变的调用流程转化到HouseDirector中
-
//抽象类
-
class House{
-
-
};
-
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 HouseDirector{
-
public:
-
HouseBuilder * pHouseBuilder;
-
HouseDirector(HouseBuilder * arg){
-
this->pHouseBuilder = arg;
-
}
-
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();
-
}
-
};
调用过程：
-
int main(){
-
House * pHouse =
new StoneHouse();
-
StoneHouseBuilder * mStoneHouseBuilder =
new StoneHouseBuilder();
-
HouseDirector * stoneHD =
new HouseDirector(mStoneHouseBuilder);
-
pHouse = stoneHD->Construct();
-
}
要点总结
Builder模式更像是一个重构的技巧，主要用于“分步骤构建一个复杂的对象”。在这其中“分步骤”是一个稳定的算法，而复杂对象的各个部分则经常变化。
变化点在哪儿里，封装哪里——Builder模式主要在于应对“复杂对象各个部分”的频繁需求变动。其缺点在于难以应对“分步骤构建算法”的需求变动。
转载：https://blog.csdn.net/qq_41605114/article/details/116028511