篇四：建造者模式：逐步构造复杂对象

篇四："建造者模式：逐步构造复杂对象"

设计模式是软件开发中的重要组成部分，建造者模式是创建型设计模式中的一种。建造者模式旨在逐步构造复杂对象，将对象的构造与其表示分离，从而使得同样的构建过程可以创建不同的表示。在C++中，建造者模式广泛应用于构建复杂对象的场景，让我们一起深入了解其核心思想和使用方法，并通过示例代码展示在C++中如何应用建造者模式来构造复杂对象。

开始本篇文章之前先推荐一个好用的学习工具，AIRIght，借助于AI助手工具，学习事半功倍。欢迎访问：http://airight.fun/。

另外有2本不错的关于设计模式的资料，分享出来与大家学习参考。

链接：https://pan.baidu.com/s/1RmhQF_o1CdK8U7s5KeILog?pwd=xc6d

提取码：xc6d

1. 建造者模式的核心思想和使用方法：

建造者模式是创建型设计模式，其核心思想是将一个复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。在建造者模式中，我们定义一个抽象建造者类，用于规范产品的构建过程，并由具体建造者类来实现该接口。然后，使用指挥者类来控制建造过程，最终构建出复杂对象。

建造者模式的使用方法如下：

定义抽象建造者类：规范产品的构建过程，包括构建部件和组装产品等方法。
定义具体建造者类：实现抽象建造者接口，负责实际构建产品的过程。
定义产品类：表示最终构建出的复杂对象。
定义指挥者类：控制建造过程，根据具体的建造者类来构建产品。

2. C++中应用建造者模式构造复杂对象的示例代码：

在C++中，我们将以创建一个复杂的电脑对象为例来展示建造者模式的应用。

a. 定义抽象建造者类：

cpp 复制代码

// ComputerBuilder.h
class ComputerBuilder {
public:
    virtual ~ComputerBuilder() {}
    virtual void buildCPU() = 0;
    virtual void buildMemory() = 0;
    virtual void buildStorage() = 0;
    virtual void buildGPU() = 0;
    virtual Computer* getResult() = 0;
};

b. 定义具体建造者类：

cpp 复制代码

// HighPerformanceComputerBuilder.h
#include "ComputerBuilder.h"

class HighPerformanceComputerBuilder : public ComputerBuilder {
public:
    HighPerformanceComputerBuilder() {
        computer_ = new Computer();
    }

    void buildCPU() override {
        computer_->setCPU("High-performance CPU");
    }

    void buildMemory() override {
        computer_->setMemory("16GB");
    }

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

    void buildGPU() override {
        computer_->setGPU("NVIDIA GeForce RTX 3080");
    }

    Computer* getResult() override {
        return computer_;
    }

private:
    Computer* computer_;
};

// StandardComputerBuilder.h
#include "ComputerBuilder.h"

class StandardComputerBuilder : public ComputerBuilder {
public:
    StandardComputerBuilder() {
        computer_ = new Computer();
    }

    void buildCPU() override {
        computer_->setCPU("Standard CPU");
    }

    void buildMemory() override {
        computer_->setMemory("8GB");
    }

    void buildStorage() override {
        computer_->setStorage("256GB SSD");
    }

    void buildGPU() override {
        computer_->setGPU("Integrated GPU");
    }

    Computer* getResult() override {
        return computer_;
    }

private:
    Computer* computer_;
};

c. 定义产品类：

cpp 复制代码

// Computer.h
#include <iostream>
#include <string>

class Computer {
public:
    void setCPU(const std::string& cpu) {
        cpu_ = cpu;
    }

    void setMemory(const std::string& memory) {
        memory_ = memory;
    }

    void setStorage(const std::string& storage) {
        storage_ = storage;
    }

    void setGPU(const std::string& gpu) {
        gpu_ = gpu;
    }

    void showInfo() const {
        std::cout << "CPU: " << cpu_ << std::endl;
        std::cout << "Memory: " << memory_ << std::endl;
        std::cout << "Storage: " << storage_ << std::endl;
        std::cout << "GPU: " << gpu_ << std::endl;
    }

private:
    std::string cpu_;
    std::string memory_;
    std::string storage_;
    std::string gpu_;
};

d. 定义指挥者类：

cpp 复制代码

// Director.h
#include "ComputerBuilder.h"

class Director {
public:
    void setBuilder(ComputerBuilder* builder) {
        builder_ = builder;
    }

    Computer* construct() {
        builder_->buildCPU();
        builder_->buildMemory();
        builder_->buildStorage();
        builder_->buildGPU();
        return builder_->getResult();
    }

private:
    ComputerBuilder* builder_;
};

e. 使用建造者模式构造复杂对象：

cpp 复制代码

// main.cpp
#include "Computer.h"
#include "Director.h"
#include "HighPerformanceComputerBuilder.h"
#include "StandardComputerBuilder.h"

int main() {
    Director director;
    HighPerformanceComputerBuilder highPerformanceBuilder;
    StandardComputerBuilder standardBuilder;

    // 构建高性能电脑
    director.setBuilder(&highPerformanceBuilder);
    Computer* highPerformanceComputer = director.construct();
    std::cout << "High Performance Computer:" << std::endl;
    highPerformanceComputer->showInfo();
    delete highPerformanceComputer;

    std::cout << std::endl;

    // 构建标准电脑
    director.setBuilder(&standardBuilder);
    Computer* standardComputer = director.construct();
    std::cout << "Standard Computer:" << std::endl;
    standardComputer->showInfo();
    delete standardComputer;

    return 0;
}

在上述示例中，我们定义了抽象建造者类ComputerBuilder，并创建了两个具体建造者类HighPerformanceComputerBuilder和StandardComputerBuilder。产品类Computer表示要构建的复杂对象。指挥者类Director负责控制建造过程，并使用不同的建造者来构建不同的复杂对象。

** 3.建造者模式的代码解析：

在建造者模式中，抽象建造者类ComputerBuilder定义了产品的构建过程，包括构建CPU、内存、存储和GPU等部件，并提供了获取最终产品的方法getResult()。具体建造者类HighPerformanceComputerBuilder和StandardComputerBuilder分别实现了抽象建造者接口，负责实际构建高性能电脑和标准电脑的过程。
产品类Computer表示最终构建出的复杂对象，其中包含CPU、内存、存储和GPU等部件，并提供了显示电脑信息的方法showInfo()。
指挥者类Director负责控制建造过程，通过setBuilder()方法设置具体的建造者，然后调用其构建方法逐步构造复杂对象。

4. 总结：

建造者模式是创建型设计模式，其核心思想是逐步构造复杂对象，将对象的构建与表示分离，使得同样的构建过程可以创建不同的表示。在C++中，通过定义抽象建造者类和具体建造者类，以及产品类和指挥者类，实现了建造者模式的应用。建造者模式使得构建过程更加灵活和可控，同时提高了代码的可维护性和可复用性。

希望本文能够帮助您更好地理解建造者模式的原理和在C++中的应用。在后续的专栏文章中，我们将继续介绍更多设计模式的知识，包括原理、详细介绍、示例代码和代码解析，帮助您深入学习和应用设计模式。

参考文献：

Gamma, E., Helm, R., Johnson, R., & Vlissides, J. (1994). Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley Professional.
C++ Core Guidelines: https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines

感谢您的阅读，欢迎一起探讨，共同进步，推荐大家使用学习助手AIRight来解答学习过程中的问题，访问链接：http://airight.fun/