建造者模式（Builder Pattern）是一种创建型设计模式，它将复杂对象的构建过程与表示分离，使得同样的构建过程可以创建不同的表示形式。这种模式特别适合创建那些具有复杂内部结构、包含多个组成部分的对象。

建造者模式的核心角色

1. 产品（Product）：被构建的复杂对象
2. 抽象建造者（Builder）：定义构建产品各个部分的接口
3. 具体建造者（Concrete Builder）：实现抽象建造者接口，具体构建产品
4. 指挥者（Director）：控制构建过程，按顺序调用建造者的方法

建造者模式的实现示例

下面以"电脑组装"为例展示建造者模式的实现，电脑由CPU、内存、硬盘等部件组成，我们可以通过不同的建造者创建不同配置的电脑：

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

// 产品：电脑
class Computer {
private:
    std::vector<std::string> parts;

public:
    void addPart(const std::string& part) {
        parts.push_back(part);
    }

    void show() const {
        std::cout << "电脑配置如下：" << std::endl;
        for (const auto& part : parts) {
            std::cout << "- " << part << std::endl;
        }
    }
};

// 抽象建造者
class ComputerBuilder {
public:
    virtual void buildCPU() = 0;
    virtual void buildMemory() = 0;
    virtual void buildHardDisk() = 0;
    virtual void buildGraphicsCard() = 0;
    virtual Computer* getResult() = 0;
    virtual ~ComputerBuilder() = default;
};

// 具体建造者：游戏电脑建造者
class GamingComputerBuilder : public ComputerBuilder {
private:
    Computer* computer;

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

    void buildCPU() override {
        computer->addPart("高性能游戏CPU");
    }

    void buildMemory() override {
        computer->addPart("32GB 高速内存");
    }

    void buildHardDisk() override {
        computer->addPart("1TB 固态硬盘");
    }

    void buildGraphicsCard() override {
        computer->addPart("顶级独立显卡");
    }

    Computer* getResult() override {
        return computer;
    }
};

// 具体建造者：办公电脑建造者
class OfficeComputerBuilder : public ComputerBuilder {
private:
    Computer* computer;

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

    void buildCPU() override {
        computer->addPart("普通办公CPU");
    }

    void buildMemory() override {
        computer->addPart("16GB 内存");
    }

    void buildHardDisk() override {
        computer->addPart("512GB 固态硬盘");
    }

    void buildGraphicsCard() override {
        computer->addPart("集成显卡");
    }

    Computer* getResult() override {
        return computer;
    }
};

// 指挥者：指导建造过程
class Director {
public:
    void construct(ComputerBuilder* builder) {
        builder->buildCPU();
        builder->buildMemory();
        builder->buildHardDisk();
        builder->buildGraphicsCard();
    }
};

// 客户端使用
int main() {
    Director director;
    
    // 构建游戏电脑
    ComputerBuilder* gamingBuilder = new GamingComputerBuilder();
    director.construct(gamingBuilder);
    Computer* gamingComputer = gamingBuilder->getResult();
    gamingComputer->show();

    std::cout << std::endl;

    // 构建办公电脑
    ComputerBuilder* officeBuilder = new OfficeComputerBuilder();
    director.construct(officeBuilder);
    Computer* officeComputer = officeBuilder->getResult();
    officeComputer->show();

    // 释放资源
    delete gamingComputer;
    delete gamingBuilder;
    delete officeComputer;
    delete officeBuilder;

    return 0;
}
    

建造者模式的工作流程

1. 客户端创建指挥者对象和具体建造者对象
2. 客户端将具体建造者对象交给指挥者
3. 指挥者调用建造者的方法，按顺序构建产品各部分
4. 客户端从建造者那里获取构建完成的产品

建造者模式与工厂模式的区别

• 工厂模式：关注于创建产品的整体，直接返回一个完整产品
• 建造者模式：关注于产品的构建过程，分步构建，最后再组装成完整产品

建造者模式的应用场景

1. 需要创建的对象具有复杂的内部结构（包含多个成员变量）
2. 需要创建的对象内部属性有一定的生成顺序或依赖关系
3. 同一个创建过程需要生成不同表现形式的产品（如不同配置的电脑）
4. 构建过程需要隔离，不暴露产品的内部结构和构建细节

建造者模式的优缺点

优点：

• 分离对象的构建与表示，使构建过程更加灵活
• 可以控制对象的构建过程，精细化管理每一步
• 便于扩展新的建造者，符合开放-封闭原则
• 隐藏产品的内部结构，降低客户端与产品的耦合

缺点：

• 增加了类的数量，系统复杂度有所提高
• 如果产品之间差异较大，需要定义多个建造者，可能导致类膨胀

建造者模式特别适合于构建复杂对象，如配置文件、文档、复杂UI组件等，它能使代码结构更清晰，构建过程更可控。