C++设计模式-Builder 构建器

通过“对象创建” 模式绕开new，来避免对象创建（new）过程中所导致的紧耦合（依赖具体类），从而支持对象创建的稳定。它是接口抽象之后的第一步工作。

一、动机

• 在软件系统中，有时候面临着“一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。

• 如何应对这种变化？如何提供一种 “封装机制”来隔离出“复杂对象的各个部分”的变化，从而保持系统中的“稳定构建算法”不随着需求改变而改变？

二、模式定义

将一个复杂对象的构建与其表示相分离，使得同样的构建过
程(稳定)可以创建不同的表示(变化)。
——《设计模式》GoF

三、代码示例

我们以房屋为例来展示建造者模式的应用。House类代表房屋对象，而HouseBuilder抽象类定义了构建房屋的步骤。StoneHouseBuilder是HouseBuilder的具体实现，用于构建石头房屋。HouseDirector类负责指导具体建造者对象的构建过程。

通过使用建造者模式，我们可以将房屋对象的构建逻辑与客户端代码分离开来。客户端只需要创建一个合适的具体建造者对象，并将其传递给指导者进行构建。这样可以使客户端代码更简洁、可读性更高，并且在需要构建不同类型的房屋时更加灵活和扩展。

#include <iostream>

class House {
public:
    void SetFoundation(const std::string& foundation) {
        this->foundation = foundation;
    }

    void SetWalls(const std::string& walls) {
        this->walls = walls;
    }

    void SetRoof(const std::string& roof) {
        this->roof = roof;
    }

    void SetDoors(const std::string& doors) {
        this->doors = doors;
    }

    void SetWindows(const std::string& windows) {
        this->windows = windows;
    }

    void Show() {
        std::cout << "房屋部分：" << std::endl;
        std::cout << "地基：" << foundation << std::endl;
        std::cout << "墙壁：" << walls << std::endl;
        std::cout << "屋顶：" << roof << std::endl;
        std::cout << "门：" << doors << std::endl;
        std::cout << "窗户：" << windows << std::endl;
    }

private:
    std::string foundation;  // 地基
    std::string walls;       // 墙壁
    std::string roof;        // 屋顶
    std::string doors;       // 门
    std::string windows;     // 窗户
};

class HouseBuilder {
public:
    virtual ~HouseBuilder() {}

    House* GetResult() {
        return pHouse;
    }

    virtual void BuildFoundation() = 0;  // 构建地基
    virtual void BuildWalls() = 0;       // 构建墙壁
    virtual void BuildRoof() = 0;        // 构建屋顶
    virtual void BuildDoors() = 0;       // 构建门
    virtual void BuildWindows() = 0;     // 构建窗户

protected:
    House* pHouse;
};

class StoneHouseBuilder : public HouseBuilder {
public:
    StoneHouseBuilder() {
        pHouse = new House();
    }

    void BuildFoundation() override {
        pHouse->SetFoundation("石头地基");
    }

    void BuildWalls() override {
        pHouse->SetWalls("石头墙壁");
    }

    void BuildRoof() override {
        pHouse->SetRoof("石头屋顶");
    }

    void BuildDoors() override {
        pHouse->SetDoors("木门");
    }

    void BuildWindows() override {
        pHouse->SetWindows("玻璃窗户");
    }
};


class HouseDirector {
public:
    HouseDirector(HouseBuilder* builder) {
        pHouseBuilder = builder;
    }

    House* Construct() {
        pHouseBuilder->BuildFoundation();  // 构建地基
        pHouseBuilder->BuildWalls();       // 构建墙壁
        pHouseBuilder->BuildRoof();        // 构建屋顶
        pHouseBuilder->BuildDoors();       // 构建门
        pHouseBuilder->BuildWindows();     // 构建窗户

        return pHouseBuilder->GetResult();
    }

private:
    HouseBuilder* pHouseBuilder;
};

int main() {
    HouseBuilder* builder = new StoneHouseBuilder();  // 使用石头房屋构建器
    HouseDirector director(builder);
    House* house = director.Construct();  // 构建房屋
    house->Show();  // 展示房屋部分

    delete house;
    delete builder;
    
    return 0;
}

输出：

房屋部分：
地基：石头地基
墙壁：石头墙壁
屋顶：石头屋顶
门：木门
窗户：玻璃窗户

这时候，假如我们有新需求，需要造一个黄金打造的房子，这时候就很方便了，只需要增加GoldenHouseBuilder 建造器，就可以完成这个扩展，不需要更改以前的代码，满足开放-封闭原则

class GoldenHouseBuilder : public HouseBuilder {
public:
    GoldenHouseBuilder() {
        pHouse = new House();
    }

    void BuildFoundation() override {
        pHouse->SetFoundation("黄金地基");
    }

    void BuildWalls() override {
        pHouse->SetWalls("黄金墙壁");
    }

    void BuildRoof() override {
        pHouse->SetRoof("黄金屋顶");
    }

    void BuildDoors() override {
        pHouse->SetDoors("金门");
    }

    void BuildWindows() override {
        pHouse->SetWindows("钻石窗户");
    }
};

调用过程

    HouseBuilder* goldenBuilder = new GoldenHouseBuilder();  // 使用黄金房屋构建器
    HouseDirector goldenDirector(goldenBuilder);
    House* goldenHouse = goldenDirector.Construct();  // 构建黄金房屋
    goldenHouse->Show();  // 展示黄金房屋部分

    delete goldenHouse;
    delete goldenBuilder;

房屋部分：
地基：黄金地基
墙壁：黄金墙壁
屋顶：黄金屋顶
门：金门
窗户：钻石窗户

四、结构

五、总结

在软件开发过程中，有时候需要构建具有复杂结构的对象。如果直接在客户端代码中创建和配置这些对象，会导致代码变得复杂且难以维护。此外，如果要构建多个具有不同配置的相似对象，每次都重复编写相似的构建代码也是低效的。为了解决这些问题，可以使用建造者模式。

建造者模式的核心思想是将对象的构建过程从其表示中分离出来。它允许你使用相同的构建过程来创建不同的表示形式。该模式将对象的构建委托给一个单独的建造者对象，该对象负责构建对象的各个部分，并最后返回构建好的对象。

在示例代码中，我们以房屋为例来展示建造者模式的应用。House类代表房屋对象，而HouseBuilder抽象类定义了构建房屋的步骤。StoneHouseBuilder和GoldenHouseBuilder是HouseBuilder的具体实现，分别用于构建石头房屋和黄金房屋。HouseDirector类负责指导具体建造者对象的构建过程。

通过使用建造者模式，我们可以将房屋对象的构建逻辑与客户端代码分离开来。客户端只需要创建一个合适的具体建造者对象，并将其传递给指导者进行构建。这样可以使客户端代码更简洁、可读性更高，并且在需要构建不同类型的房屋时更加灵活和扩展。

建造者模式适用于构建复杂对象的情况，将构建逻辑与表示分离，使得构建过程更加灵活和可扩展。它提供了一种组织和管理对象构建的方式，避免了繁琐和重复的构建代码。通过委托具体的建造者对象来构建对象，客户端代码可以专注于高级操作，而无需关心对象的内部构建细节。