C++设计模式之创建型模式：建造者模式（Builder）

建造者模式（Builder）是创建型设计模式的一种，它专注于将复杂对象的构建过程与表示分离，通过分步构建的方式，灵活创建不同配置的对象。这种模式特别适合创建具有多个部件、配置复杂且需要灵活组合的对象（如汽车、文档、电脑等）。

一、核心角色与设计思想

建造者模式通过以下4个核心角色实现"构建与表示分离"：

角色名称	核心职责
产品（Product）	被构建的复杂对象，包含多个部件（如电脑包含CPU、内存、硬盘等）。
抽象建造者（Builder）	声明构建产品各部件的抽象接口（如buildCPU()、buildRAM()），定义获取最终产品的方法。
具体建造者（Concrete Builder）	实现抽象建造者接口，负责具体部件的构建和组装，记录产品的具体配置。
指挥者（Director）	控制构建流程（即调用建造者的哪些方法及顺序），不直接参与产品构建，仅负责流程调度。

核心思想：将复杂对象的"构建步骤"与"部件实现"分离，使得相同的构建流程可以创建不同表示的产品（如同一流程可构建"游戏本"和"办公本"）。

二、实现示例（电脑组装场景）

假设我们需要构建不同配置的电脑（游戏本和办公本），包含CPU、内存、硬盘等部件，使用建造者模式的实现如下：

#include <iostream>
#include <string>
#include <vector>
#include <memory>

// 1. 产品（Product）：电脑
class Computer {
private:
    std::string cpu;    // 处理器
    std::string ram;    // 内存
    std::string disk;   // 磁盘
    std::vector<std::string> peripherals; // 外设

public:
    // 设置部件
    void setCPU(const std::string& c) { cpu = c; }
    void setRAM(const std::string& r) { ram = r; }
    void setDisk(const std::string& d) { disk = d; }
    void addPeripheral(const std::string& p) { peripherals.push_back(p); }

    // 显示配置
    void showConfig() const {
        std::cout << "电脑配置：" << std::endl;
        std::cout << "CPU: " << cpu << std::endl;
        std::cout << "内存: " << ram << std::endl;
        std::cout << "磁盘: " << disk << std::endl;
        std::cout << "外设: ";
        for (const auto& p : peripherals) {
            std::cout << p << " ";
        }
        std::cout << std::endl << std::endl;
    }
};

// 2. 抽象建造者（Builder）
class ComputerBuilder {
public:
    // 纯虚方法：构建各部件
    virtual void buildCPU() = 0;
    virtual void buildRAM() = 0;
    virtual void buildDisk() = 0;
    virtual void buildPeripherals() = 0;

    // 获取构建完成的产品
    virtual Computer* getResult() = 0;

    virtual ~ComputerBuilder() = default;
};

// 3. 具体建造者1：游戏本建造者
class GamingPCBuilder : public ComputerBuilder {
private:
    Computer* computer; // 正在构建的产品

public:
    GamingPCBuilder() { computer = new Computer(); }

    void buildCPU() override {
        computer->setCPU("Intel i9-13900K"); // 高性能CPU
    }

    void buildRAM() override {
        computer->setRAM("32GB DDR5"); // 大容量高速内存
    }

    void buildDisk() override {
        computer->setDisk("1TB NVMe SSD"); // 高速固态硬盘
    }

    void buildPeripherals() override {
        computer->addPeripheral("机械键盘");
        computer->addPeripheral("电竞鼠标");
        computer->addPeripheral("高清显示器");
    }

    Computer* getResult() override {
        return computer; // 返回构建好的游戏本
    }
};

// 3. 具体建造者2：办公本建造者
class OfficePCBuilder : public ComputerBuilder {
private:
    Computer* computer;

public:
    OfficePCBuilder() { computer = new Computer(); }

    void buildCPU() override {
        computer->setCPU("Intel i5-13400"); // 均衡型CPU
    }

    void buildRAM() override {
        computer->setRAM("16GB DDR4"); // 够用的内存
    }

    void buildDisk() override {
        computer->setDisk("512GB SATA SSD"); // 普通固态硬盘
    }

    void buildPeripherals() override {
        computer->addPeripheral("无线鼠标");
        computer->addPeripheral("普通显示器");
    }

    Computer* getResult() override {
        return computer; // 返回构建好的办公本
    }
};

// 4. 指挥者（Director）：控制构建流程
class Director {
public:
    // 固定构建流程：按顺序调用建造者的方法
    Computer* construct(ComputerBuilder* builder) {
        builder->buildCPU();
        builder->buildRAM();
        builder->buildDisk();
        builder->buildPeripherals();
        return builder->getResult(); // 返回最终产品
    }
};

// 客户端代码
int main() {
    Director director; // 指挥者

    // 构建游戏本
    GamingPCBuilder gamingBuilder;
    Computer* gamingPC = director.construct(&gamingBuilder);
    std::cout << "=== 游戏本 ===" << std::endl;
    gamingPC->showConfig();

    // 构建办公本
    OfficePCBuilder officeBuilder;
    Computer* officePC = director.construct(&officeBuilder);
    std::cout << "=== 办公本 ===" << std::endl;
    officePC->showConfig();

    // 释放资源
    delete gamingPC;
    delete officePC;

    return 0;
}

三、代码解析

1. 产品（Computer）：包含多个部件（CPU、内存等），提供设置部件和展示配置的方法。
2. 抽象建造者（ComputerBuilder） ：声明构建各部件的接口（buildCPU()等）和获取产品的方法（getResult()）。
3. 具体建造者 ：
   • GamingPCBuilder：实现游戏本的部件构建（高性能CPU、大容量内存等）。
   • OfficePCBuilder：实现办公本的部件构建（均衡配置）。
4. 指挥者（Director）：定义固定的构建流程（先CPU、再内存等），通过调用具体建造者的方法完成构建，不关心具体部件细节。

四、核心优势

1. 解耦构建与表示：构建流程（指挥者）与部件实现（具体建造者）分离，相同流程可创建不同产品。
2. 灵活定制产品：通过更换具体建造者，可在不修改构建流程的情况下，得到不同配置的产品（如游戏本 vs 办公本）。
3. 控制构建细节：将复杂对象的构建步骤拆分，每一步骤由专门方法实现，逻辑清晰，便于维护。
4. 隐藏创建过程：客户端只需指定具体建造者，无需知道产品的内部组成和构建细节。

五、适用场景

1. 当对象包含多个部件，且部件需要按一定顺序构建时（如电脑、汽车、文档）。
2. 当需要创建不同配置的同类产品时（如不同配置的手机、不同风格的文档）。
3. 当对象构建过程复杂，且希望将构建逻辑与产品本身分离时。

六、与工厂模式的区别

对比维度	建造者模式	工厂模式（抽象/工厂方法）
核心目标	分步构建复杂对象，关注"如何构建"	批量创建产品，关注"创建什么"
产品复杂度	处理多部件、多配置的复杂产品	通常处理单一或关联产品族
构建过程	构建步骤明确，可由指挥者控制	通常一步完成对象创建
灵活性	可精细控制每个部件的构建细节	侧重产品类型的选择，细节固定

一句话总结：工厂模式是"一键生产产品"，建造者模式是"分步定制产品"。

七、扩展与实践建议

1. 省略指挥者：若构建流程简单，可由客户端直接调用建造者的方法（无需指挥者）。
2. 链式调用 ：让建造者方法返回*this，支持链式调用（如builder->buildCPU()->buildRAM()）。
3. 产品不可变 ：构建完成后，产品应禁止修改（可移除setXXX方法，仅在建造者中设置部件）。
4. 结合单例 ：若建造者无状态，可设计为单例，避免重复创建（如GamingPCBuilder::getInstance()）。

建造者模式的核心价值在于"将复杂对象的构建过程标准化，同时保留产品配置的灵活性"。在需要创建多部件、多配置的对象时，它能显著提升代码的可读性和可维护性，是处理复杂对象创建的最佳实践之一。