设计模式---构建者模式（Builder Pattern）

构建者模式（Builder Pattern） 是一种创建型设计模式，旨在将复杂对象的构建过程与其表示分离。它允许使用相同的构建过程创建不同的表示。该模式通常用于构建复杂对象，这些对象由多个部分组成或具有多个可选属性。

构建者模式的核心要素：

1. Builder（构建者）：定义构建对象的接口，声明创建部分对象的方法。
2. ConcreteBuilder（具体构建者）：实现 Builder 接口，构建并装配各个部件，提供一个方法以获取最终构建的对象。
3. Director（指挥者）：构建过程中的协调者，使用 Builder 对象来构建产品。
4. Product（产品）：由 Builder 构建的最终对象，通常包含多个部件。

示例：创建一个复杂的 Computer 对象

我们将使用构建者模式来创建一个 Computer 对象。一个 Computer 可能包括处理器、内存、硬盘和显卡等部件。

1. 定义 Computer 类（产品）

#include <string>
#include <iostream>

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 showSpecs() const {
        std::cout << "Computer Specifications:" << std::endl;
        std::cout << "CPU: " << m_cpu << std::endl;
        std::cout << "RAM: " << m_ram << std::endl;
        std::cout << "Storage: " << m_storage << std::endl;
        std::cout << "GPU: " << m_gpu << std::endl;
    }

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

2. 定义 Builder 接口

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. 定义 ConcreteBuilder（具体构建者）

class GamingComputerBuilder : public ComputerBuilder {
public:
    GamingComputerBuilder() { m_computer = new Computer(); }
    ~GamingComputerBuilder() { delete m_computer; }

    void buildCPU() override { m_computer->setCPU("High-end CPU"); }
    void buildRAM() override { m_computer->setRAM("16GB RAM"); }
    void buildStorage() override { m_computer->setStorage("1TB SSD"); }
    void buildGPU() override { m_computer->setGPU("High-end GPU"); }

    Computer* getComputer() override { return m_computer; }

private:
    Computer* m_computer;
};

4. 定义 Director（指挥者）

class ComputerDirector {
public:
    ComputerDirector(ComputerBuilder* builder) : m_builder(builder) {}

    void construct() {
        m_builder->buildCPU();
        m_builder->buildRAM();
        m_builder->buildStorage();
        m_builder->buildGPU();
    }

private:
    ComputerBuilder* m_builder;
};

5. 使用构建者模式

int main() {
    // 创建具体构建者对象
    ComputerBuilder* builder = new GamingComputerBuilder();

    // 创建指挥者对象，并传入具体构建者
    ComputerDirector director(builder);

    // 开始构建过程
    director.construct();

    // 获取构建完成的产品
    Computer* computer = builder->getComputer();
    computer->showSpecs();

    // 清理资源
    delete computer;
    delete builder;

    return 0;
}

解释

• Computer 类是最终构建的对象，包含多个属性（部件）。
• ComputerBuilder 是构建者接口，定义了构建每个部件的方法。
• GamingComputerBuilder 是一个具体构建者，实现了构建每个部件的方法，并返回最终构建的 Computer 对象。
• ComputerDirector 使用构建者来构建产品，它知道如何一步一步地构建 Computer 对象，但不直接处理构建过程的细节。
• main 函数 中创建了一个 GamingComputerBuilder 实例和一个 ComputerDirector 实例，然后使用 ComputerDirector 来构建 Computer 对象，并显示其规格。

通过构建者模式，你可以轻松地创建不同配置的 Computer 对象（如 GamingComputerBuilder），并且可以在不改变构建过程的情况下，创建其他类型的计算机（例如 OfficeComputerBuilder）。