C++ 设计模式 构建器

以下内容均来自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模式主要在于应对“复杂对象各个部分”的频繁需求变动。其缺点在于难以应对“分步骤构建算法”的需求变动。