建造者模式C++

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

建造者模式的核心角色

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

C++实现示例

以下以"电脑"为例实现建造者模式，电脑由主板、CPU、内存、显卡等部件组成，我们可以通过不同的建造者创建不同配置的电脑。

复制代码

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

// 产品：电脑
class Computer {
private:
    std::string motherboard;  // 主板
    std::string cpu;          // CPU
    std::string memory;       // 内存
    std::string graphicsCard; // 显卡
    std::string storage;      // 存储设备

public:
    void setMotherboard(const std::string& mb) { motherboard = mb; }
    void setCPU(const std::string& c) { cpu = c; }
    void setMemory(const std::string& m) { memory = m; }
    void setGraphicsCard(const std::string& gc) { graphicsCard = gc; }
    void setStorage(const std::string& s) { storage = s; }

    // 显示电脑配置
    void showConfiguration() const {
        std::cout << "电脑配置:\n";
        std::cout << "主板: " << motherboard << "\n";
        std::cout << "CPU: " << cpu << "\n";
        std::cout << "内存: " << memory << "\n";
        std::cout << "显卡: " << graphicsCard << "\n";
        std::cout << "存储: " << storage << "\n\n";
    }
};

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

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

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

    void buildMotherboard() override {
        computer->setMotherboard("高端游戏主板");
    }

    void buildCPU() override {
        computer->setCPU("高性能多核处理器");
    }

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

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

    void buildStorage() override {
        computer->setStorage("1TB NVMe SSD");
    }

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

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

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

    void buildMotherboard() override {
        computer->setMotherboard("普通办公主板");
    }

    void buildCPU() override {
        computer->setCPU("中端处理器");
    }

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

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

    void buildStorage() override {
        computer->setStorage("512GB SSD");
    }

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

// 指挥者：指导建造过程
class Director {
public:
    // 按固定流程构建电脑
    void construct(ComputerBuilder* builder) {
        builder->buildMotherboard();
        builder->buildCPU();
        builder->buildMemory();
        builder->buildGraphicsCard();
        builder->buildStorage();
    }
};

int main() {
    Director director;
    
    // 构建游戏电脑
    ComputerBuilder* gamingBuilder = new GamingComputerBuilder();
    director.construct(gamingBuilder);
    Computer* gamingPC = gamingBuilder->getResult();
    std::cout << "游戏电脑:\n";
    gamingPC->showConfiguration();

    // 构建办公电脑
    ComputerBuilder* officeBuilder = new OfficeComputerBuilder();
    director.construct(officeBuilder);
    Computer* officePC = officeBuilder->getResult();
    std::cout << "办公电脑:\n";
    officePC->showConfiguration();

    // 清理资源
    delete gamingBuilder;  // 注意：会同时删除内部的Computer对象
    delete officeBuilder;

    return 0;
}

代码解析

Computer类：表示被构建的复杂产品，包含多个组件（主板、CPU等）和展示配置的方法。
ComputerBuilder类：抽象建造者，定义了构建电脑各组件的接口方法，以及获取最终产品的方法。
具体建造者：
- GamingComputerBuilder：构建高性能游戏电脑，各组件都选择高端配置
- OfficeComputerBuilder：构建办公电脑，配置满足日常办公需求即可
Director类：指挥者，负责控制构建流程，按固定顺序调用建造者的方法，使构建过程标准化。

建造者模式的优缺点

优点：

将复杂对象的构建与表示分离，客户端无需知道内部组成细节
可以灵活切换不同的建造者，得到不同的产品配置
便于扩展新的建造者，符合开放-封闭原则
控制了对象的构建过程，确保构建步骤的完整性

缺点：

增加了类的数量，系统复杂度有所提高
如果产品内部结构变化频繁，需要修改所有建造者类

适用场景

当创建的对象具有复杂的内部结构（包含多个成员变量）
当需要创建的对象有不同的配置或表示形式
当希望隐藏复杂对象的创建细节，只暴露构建过程

常见应用：

文档生成器（如生成不同格式的文档：PDF、HTML等）
游戏角色创建（不同职业、不同装备的角色）
汽车制造（不同型号、配置的汽车）
数据库连接配置构建

建造者模式与工厂模式的区别在于：工厂模式注重整体对象的创建，而建造者模式注重对象的分步构建过程，适合创建复杂对象。