创建型模式之建造者模式

最新推荐文章于 2025-05-28 18:31:15 发布

oxma

最新推荐文章于 2025-05-28 18:31:15 发布

阅读量74

点赞数 1

分类专栏：浅谈设计模式文章标签：建造者模式 linux c++ 开发语言

本文链接：https://blog.youkuaiyun.com/khh1014173041/article/details/132872237

版权

浅谈设计模式专栏收录该内容

4 篇文章

订阅专栏

什么是建造者模式

建造者模式（Builder Pattern）是一种创建型设计模式，它可以将一个复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。

建造者模式通常适用于以下场景：

需要创建一个复杂对象，该对象由多个部分组成，且这些部分的创建过程相对独立。
需要创建的对象有多个不同的表示，而不同的表示之间可以共享部分相同的构建步骤。

建筑者模式的抽象概念

建造者模式主要包含以下几个角色：

产品（Product）：表示被构建的复杂对象，通常包含多个部分。
抽象建造者（Builder）：定义了构建产品的抽象方法和获取产品的方法。
具体建造者（Concrete Builder）：实现了抽象建造者接口，负责具体的构建过程和组装产品。
指挥者（Director）：负责调用具体建造者的方法来构建产品，它不直接与产品交互。

具体的代码样例

下面是一个示例代码，展示了如何使用建造者模式创建一个电脑对象：

#include <iostream>
#include <string>

// 产品类：电脑
class Computer {
public:
    void setCPU(const std::string& cpu) {
        m_cpu = cpu;
    }
    
    void setMemory(const std::string& memory) {
        m_memory = memory;
    }
    
    void setHardDisk(const std::string& hardDisk) {
        m_hardDisk = hardDisk;
    }
    
    void show() {
        std::cout << "CPU: " << m_cpu << std::endl;
        std::cout << "Memory: " << m_memory << std::endl;
        std::cout << "Hard Disk: " << m_hardDisk << std::endl;
    }
    
private:
    std::string m_cpu;
    std::string m_memory;
    std::string m_hardDisk;
};

// 抽象建造者类
class Builder {
public:
    virtual void buildCPU() = 0;
    virtual void buildMemory() = 0;
    virtual void buildHardDisk() = 0;
    virtual Computer* getComputer() = 0;
};

// 具体建造者类：台式机建造者
class DesktopBuilder : public Builder {
public:
    void buildCPU() override {
        m_computer->setCPU("Intel i7");
    }
    
    void buildMemory() override {
        m_computer->setMemory("16GB");
    }
    
    void buildHardDisk() override {
        m_computer->setHardDisk("1TB");
    }
    
    Computer* getComputer() override {
        return m_computer;
    }
    
private:
    Computer* m_computer = new Computer();
};

// 具体建造者类：笔记本建造者
class LaptopBuilder : public Builder {
public:
    void buildCPU() override {
        m_computer->setCPU("Intel i5");
    }
    
    void buildMemory() override {
        m_computer->setMemory("8GB");
    }
    
    void buildHardDisk() override {
        m_computer->setHardDisk("512GB");
    }
    
    Computer* getComputer() override {
        return m_computer;
    }
    
private:
    Computer* m_computer = new Computer();
};

// 指挥者类
class Director {
public:
    void construct(Builder* builder) {
        builder->buildCPU();
        builder->buildMemory();
        builder->buildHardDisk();
    }
};

int main() {
    Director director;
    
    Builder* desktopBuilder = new DesktopBuilder();
    director.construct(desktopBuilder);
    Computer* desktop = desktopBuilder->getComputer();
    desktop->show();
    delete desktopBuilder;
    delete desktop;
    
    Builder* laptopBuilder = new LaptopBuilder();
    director.construct(laptopBuilder);
    Computer* laptop = laptopBuilder->getComputer();
    laptop->show();
    delete laptopBuilder;
    delete laptop;
    
    return 0;
}

在上述示例中，我们定义了产品类 Computer，它包含了三个部分：CPU、内存和硬盘。然后，我们定义了抽象建造者类 Builder，其中包含了构建产品的抽象方法和获取产品的方法。接着，我们定义了两个具体建造者类 DesktopBuilder 和 LaptopBuilder，它们分别实现了抽象建造者接口，负责具体的构建过程和组装产品。最后，我们定义了指挥者类 Director，它负责调用具体建造者的方法来构建产品。

在客户端代码中，我们首先创建一个指挥者对象，然后创建一个具体建造者对象，并将其传递给指挥者的 construct 方法。指挥者根据具体建造者的实现来调用相应的构建方法，最终得到一个完整的产品对象。我们可以通过具体建造者的 getComputer 方法来获取构建好的产品，并进行后续操作。