设计模式---构建者模式(Builder Pattern)-LMLPHP

构建者模式(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)。

08-17 16:16