C++怎么实现一个建造者设计模式_C++创建型模式与复杂对象构建

建造者模式通过分离复杂对象的构建与表示，使同一构建过程可创建不同配置的Computer对象，提升代码可读性与维护性。

建造者模式用于分离复杂对象的构建和表示，使得同样的构建过程可以创建不同的表示。在C++中，当一个类的构造函数参数过多，或者对象的构建步骤较复杂、存在多种变体时，使用建造者模式能显著提升代码可读性和可维护性。

建造者模式的核心思想

将对象的构建逻辑从构造函数中剥离出来，通过一个独立的Builder类逐步配置和组装对象。最终通过build()方法生成目标对象。这种方式避免了“伸缩构造器反模式”（telescoping constructors），即写多个参数不同的构造函数。

比如我们要构建一个复杂的Computer类，包含CPU、内存、硬盘、显卡等组件，不同配置组合多样。

基本实现结构

定义产品类、抽象建造者、具体建造者和指挥者（可选）。

示例代码：

#include 
#include 

// 1. 产品类：Computer
class Computer {
public:
    void setCPU(const std::string& cpu) { m_cpu = cpu; }
    void setRAM(const std::string& ram) { m_ram = ram; }
    void setStorage(const std::string& storage) { m_storage = storage; }
    void setGPU(const std::string& gpu) { m_gpu = gpu; }

    void show() const {
        std::cout << "Computer Config:\n";
        std::cout << "  CPU: " << m_cpu << "\n";
        std::cout << "  RAM: " << m_ram << "\n";
        std::cout << "  Storage: " << m_storage << "\n";
        std::cout << "  GPU: " << m_gpu << "\n";
    }

private:
    std::string m_cpu;
    std::string m_ram;
    std::string m_storage;
    std::string m_gpu;
};

// 2. 抽象建造者
class ComputerBuilder {
public:
    virtual ~ComputerBuilder() = default;
    virtual void buildCPU() = 0;
    virtual void buildRAM() = 0;
    virtual void buildStorage() = 0;
    virtual void buildGPU() = 0;
    virtual Computer* getComputer() = 0;
};

// 3. 具体建造者：游戏电脑
class GamingComputerBuilder : public ComputerBuilder {
public:
    GamingComputerBuilder() { m_computer = new Computer(); }

    void buildCPU() override { m_computer->setCPU("Intel i9"); }
    void buildRAM() override { m_computer->setRAM("32GB DDR5"); }
    void buildStorage() override { m_computer->setStorage("1TB NVMe SSD"); }
    void buildGPU() override { m_computer->setGPU("RTX 4090"); }

    Computer* getComputer() override {
        Computer* temp = m_computer;
        m_computer = nullptr;
        return temp;
    }

    ~GamingComputerBuilder() {
        delete m_computer;
    }

private:
    Computer* m_computer;
};

// 4. 具体建造者：办公电脑
class OfficeComputerBuilder : public ComputerBuilder {
public:
    OfficeComputerBuilder() { m_computer = new Computer(); }

    void buildCPU() override { m_computer->setCPU("Intel i5"); }
    void buildRAM() override { m_computer->setRAM("16GB DDR4"); }
    void buildStorage() override { m_computer->setStorage("512GB SATA SSD"); }
    void buildGPU() override { m_computer->setGPU("Integrated Graphics"); }

    Computer* getComputer() override {
        Computer* temp = m_computer;
        m_computer = nullptr;
        return temp;
    }

    ~OfficeComputerBuilder() {
        delete m_computer;
    }

private:
    Computer* m_computer;
};

// 5. 指挥者（可选）
class Director {
public:
    void setBuilder(ComputerBuilder* builder) { m_builder = builder; }

    Computer* construct() {
        m_builder->buildCPU();
        m_builder->buildRAM();
        m_builder->buildStorage();
        m_builder->buildGPU();
        return m_builder->getComputer();
    }

private:
    ComputerBuilder* m_builder;
};

使用方式

通过Director控制构建流程，或直接调用Builder的各个步骤。

int main() {
    Director director;
    GamingComputerBuilder gamingBuilder;
    OfficeComputerBuilder officeBuilder;

    // 构建游戏电脑
    director.setBuilder(&gamingBuilder);
    Computer* gamingPC = director.construct();
    gamingPC->show();

    std::cout << "\n";

    // 构建办公电脑
    director.setBuilder(&officeBuilder);
    Computer* officePC = director.construct();
    officePC->show();

    delete gamingPC;
    delete officePC;

    return 0;
}

现代C++中的流式建造者（Fluent Builder）

更符合C++习惯的方式是使用链式调用，提升API易用性。

class Computer {
public:
    Computer& cpu(const std::string& c) { m_cpu = c; return *this; }
    Computer& ram(const std::string& r) { m_ram = r; return *this; }
    Computer& storage(const std::string& s) { m_storage = s; return *this; }
    Computer& gpu(const std::string& g) { m_gpu = g; return *this; }

    void show() const {
        std::cout << "Custom Computer:\n";
        std::cout << "  CPU: " << m_cpu << "\n";
        std::cout << "  RAM: " << m_ram << "\n";
        std::cout << "  Storage: " << m_storage << "\n";
        std::cout << "  GPU: " << m_gpu << "\n";
    }

private:
    std::string m_cpu;
    std::string m_ram;
    std::string m_storage;
    std::string m_gpu;
};

// 使用示例
/*
Computer myPC;
myPC.cpu("AMD Ryzen 7")
     .ram("32GB")
     .storage("2TB SSD")
     .gpu("RTX 4070")
     .show();
*/

这种风格简洁直观，适合配置类对象，广泛应用于现代C++库设计中。

基本上就这些。根据实际需求选择传统建造者或流式接口，关键是把复杂构建逻辑封装好，让使用者专注配置而非细节。

# 显卡 # 电脑 # 硬盘 # office # ai # amd # c++ # ios # stream # 代码可读性 # 封装 # 构造函数 # 接口 # 对象 # 可选 # 链式 # 流式 # 多个 # 应用于 # 而非 # 装好 # 更符合 # 易用性 # 构建一个

返回目录在线咨询

上一篇：Ubuntu 14.04 更换阿里云源的方法
下一篇：如何在Siteground上安装WordPress？

您的项目需求