C++建造者模式详解：分步构建复杂对象

建造者模式在C++中的核心思想是将复杂对象的构建过程与其最终表示解耦，适用于对象创建涉及多个有序步骤或大量可选部件的场景。1. 它通过四个主要角色协同工作：产品（Product）仅包含组成部分；抽象建造者（Builder）定义构建接口；具体建造者（Concrete Builder）实现部件构建逻辑；指挥者（Director）控制构建流程。2. 该模式使构建过程与表示分离，提升代码可读性、可维护性和扩展性。3. 相比工厂方法和抽象工厂，建造者更适合多步骤、可变顺序的对象构建任务。4. 常见应用场景包括高度定制化的对象创建，如不同配置的计算机、多种格式的文档生成以及参数复杂的网络请求对象构建等。

建造者模式在C++中，核心思想就是将一个复杂对象的构建过程与其最终表示解耦。你可以把它想象成一个高度定制化的产品组装流水线：你告诉流水线主管（Director）你想要什么类型的产品，然后一个专门的工人（Builder）会按照你的要求，一步一步、一丝不苟地把各个部件组装起来，最终交付给你一个完整的、符合预期的产品。它特别适合那些对象拥有大量可选部件，或者其创建过程需要遵循特定、有序步骤的场景。

解决方案

应用建造者模式，通常会涉及四个主要角色，它们协同工作来完成复杂对象的构建：

• 产品（Product）: 这是我们最终想要构建的复杂对象。它只关心自己由哪些部分组成，而不关心这些部分是如何被创建或组装的。例如，一辆汽车，它有车身、引擎、轮胎等，但它不知道是谁把这些部件装配起来的。
• 抽象建造者（Builder）: 这是一个接口或抽象类，定义了构建产品各个部件的方法，以及一个获取最终产品的方法。它规定了“可以构建哪些部件”，但没有具体说明“如何构建”。
• 具体建造者（Concrete Builder）: 实现了抽象建造者接口，负责具体地构建产品的各个部件。每个具体建造者都专注于构建特定类型的产品变体。比如，一个“跑车建造者”会构建跑车的车身、引擎和轮胎，而一个“SUV建造者”则会构建SUV的相应部件。它们会维护一个正在构建中的产品实例，并在构建完成后通过 getResult() 或类似的接口返回。
• 指挥者（Director）: 这个角色负责协调构建过程。它接收一个具体建造者对象，然后按照特定的顺序调用建造者的方法来构建产品。指挥者并不知道产品部件的具体实现细节，它只知道构建一个特定产品所需的步骤序列。这使得你可以用相同的构建过程（Director的 construct 方法）来构建不同类型的产品，只要提供不同的具体建造者即可。

这种模式的精髓在于将“如何构建一个复杂对象”的逻辑从“表示这个复杂对象”的逻辑中分离出来。当对象的构造函数参数过多，或者对象的构建过程非常复杂且可能存在多种变体时，建造者模式能极大地提高代码的可读性、可维护性和扩展性。

例如，假设我们要构建一个 Computer 对象，它可能包含 CPU, RAM, `Storage, GPU, OS 等部件。这些部件有多种选择，而且某些组合可能不兼容。

#include 
#include 
#include  // For std::unique_ptr

// 1. 产品 (Product)
class Computer {
public:
    void setCPU(const std::string& cpu) { cpu_ = cpu; }
    void setRAM(const std::string& ram) { ram_ = ram; }
    void setStorage(const std::string& storage) { storage_ = storage; }
    void setGPU(const std::string& gpu) { gpu_ = gpu; }
    void setOS(const std::string& os) { os_ = os; }

    void showConfiguration() const {
        std::cout << "--- Computer Configuration ---" << std::endl;
        std::cout << "CPU: " << cpu_ << std::endl;
        std::cout << "RAM: " << ram_ << std::endl;
        std::cout << "Storage: " << storage_ << std::endl;
        std::cout << "GPU: " << gpu_ << std::endl;
        std::cout << "OS: " << os_ << std::endl;
        std::cout << "----------------------------" << std::endl;
    }

private:
    std::string cpu_;
    std::string ram_;
    std::string storage_;
    std::string gpu_;
    std::string os_;
};

// 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 void buildOS() = 0;
    virtual std::unique_ptr getComputer() = 0;
};

// 3. 具体建造者 (Concrete Builder) - 用于构建高端游戏电脑
class GamingComputerBuilder : public ComputerBuilder {
private:
    std::unique_ptr computer_;

public:
    GamingComputerBuilder() : computer_(std::make_unique()) {}

    void buildCPU() override { computer_->setCPU("Intel Core i9"); }
    void buildRAM() override { computer_->setRAM("32GB DDR5"); }
    void buildStorage() override { computer_->setStorage("1TB NVMe SSD"); }
    void buildGPU() override { computer_->setGPU("NVIDIA GeForce RTX 4090"); }
    void buildOS() override { computer_->setOS("Windows 11 Pro"); }

    std::unique_ptr getComputer() override {
        return std::move(computer_); // 返回所有权，并重置内部指针
    }
};

// 另一个具体建造者 - 用于构建办公电脑
class OfficeComputerBuilder : public ComputerBuilder {
private:
    std::unique_ptr computer_;

public:
    OfficeComputerBuilder() : computer_(std::make_unique()) {}

    void buildCPU() override { computer_->setCPU("Intel Core i5"); }
    void buildRAM() override { computer_->setRAM("16GB DDR4"); }
    void buildStorage() override { computer_->setStorage("512GB SATA SSD"); }
    void buildGPU() override { computer_->setGPU("Integrated Graphics"); }
    void buildOS() override { computer_->setOS("Windows 10 Home"); }

    std::unique_ptr getComputer() override {
        return std::move(computer_);
    }
};

// 4. 指挥者 (Director)
class ComputerAssembler {
public:
    void assembleGamingComputer(ComputerBuilder* builder) {
        builder->buildCPU();
        builder->buildRAM();
        builder->buildStorage();
        builder->buildGPU();
        builder->buildOS();
    }

    void assembleOfficeComputer(ComputerBuilder* builder) {
        builder->buildCPU();
        builder->buildRAM();
        builder->buildStorage();
        builder->buildOS(); // 办公电脑可能不需要独立显卡
    }
    // 可以有更多不同配置的组装方法
};

/*
// 客户端代码示例
int main() {
    ComputerAssembler assembler;

    // 组装一台游戏电脑
    GamingComputerBuilder gamingBuilder;
    assembler.assembleGamingComputer(&gamingBuilder);
    std::unique_ptr gamingComputer = gamingBuilder.getComputer();
    if (gamingComputer) {
        gamingComputer->showConfiguration();
    }

    // 组装一台办公电脑
    OfficeComputerBuilder officeBuilder;
    assembler.assembleOfficeComputer(&officeBuilder);
    std::unique_ptr officeComputer = officeBuilder.getComputer();
    if (officeComputer) {
        officeComputer->showConfiguration();
    }

    return 0;
}
*/

这个例子清晰地展示了，通过 ComputerAssembler (Director) 和不同的 ComputerBuilder，我们能够灵活地创建不同配置的 Computer 对象，而客户端代码只需要与 Director 和 Builder 接口打交道，无需关心具体的构建细节。

为什么选择建造者模式而非其他创建型模式？

这是一个经常被问到的问题，毕竟创建型模式家族里成员不少。什么时候建造者模式能脱颖而出呢？

我认为，最核心的考量点在于“复杂对象的分步构建”和“表示与构建的分离”。当一个对象的构造过程不仅仅是简单地调用一个构造函数就能搞定，而是需要一系列有序的、可能带有条件判断的步骤，并且这些步骤的顺序或具体实现会根据最终产品的不同而变化时，建造者模式的优势就非常明显了。

举个例子，假设你正在开发一个复杂的文档生成器，它可以生成各种格式的文档：HTML、Markdown、PDF草稿。一份文档可以包含标题、段落、列表、图片、表格等。不同格式的文档，这些元素的表示方式截然不同；不同类型的文档（比如技术手册、市场宣传册），元素的组合顺序和内容也可能不一样。

• 如果用工厂方法： 你可能需要为每种文档类型创建一个工厂，但工厂方法通常只负责创建“一个”产品实例，而不是“一步步组装”一个复杂产品。它更侧重于决定创建哪个具体类的对象，而不是如何构建这个对象的内部结构。它无法很好地处理这种多步骤、可变序列的构建。
• 如果用抽象工厂： 抽象工厂是用来创建“一系列相关或相互依赖的对象家族”的。比如一个UI工厂可以创建Windows风格的按钮和文本框，或者Mac风格的按钮和文本框。它关注的是产品家族的兼容性，而不是一个单一复杂产品的内部构建流程。它在管理多套相互关联的组件集时很强大，但在构建一个由多个可选且有序步骤组成的对象时，就不那么直接了。
• 建造者模式的优势： 在文档生成这个场景下，建造者模式就能完美契合。你可以有一个 DocumentBuilder 接口，定义 buildTitle(), buildParagraph(), buildImage(), buildTable() 等方法。然后有 HtmlDocumentBuilder, MarkdownDocumentBuilder, PdfDraftBuilder 等具体建造者，它们各自实现这些方法，以不同的方式组装文档的各个部分。而 DocumentDirector 只需要知道“我需要一个技术手册”，然后调用 builder->buildTitle(); builder->buildParagraph(); builder->buildImage(); 这样的序列，而无需关心这些部分具体是怎么生成的，或者最终是HTML还是PDF。

所以，当构造逻辑变得复杂，涉及多步、多变，并且你希望将“如何构建”与“构建什么”解耦时，建造者模式往往是首选。它提供了一种更细粒度的控制，让构建过程更加灵活和可扩展。它允许你通过不同的建造者实现来生产同一类型产品的不同“风味”，或者通过不同的指挥者来以不同的顺序组装部件。

建造者模式在实际项目中的常见应用场景是什么？

在实际的软件开发中，建造者模式的应用场景远比我们想象的要多，尤其是在那些需要高度配置或多种变体的复杂对象构建上。

一个非常典型的场景就是配置对象或参数的构建。比如，一个网络请求对象 HttpRequest，它可能有URL、方法（GET/POST）、各种Header、请求体、超时时间、认证信息等等。如果用构造函数来承载这些，那参数列表会变得异常庞大且难以维护，甚至需要大量的重载构造函数来应对各种参数组合。通过建造者模式，你可以用一种非常流畅、可读性极高的方式来构建它，这通常被称为“链式调用”或“流式接口”。

// 伪代码，C++中通过返回*this实现
class HttpRequest {
public:
    // ... 私有成员和设置方法
    void send() { /* ... */ }
};

class HttpRequestBuilder {
private:
    HttpRequest request_; // 正在构建的请求对象

public:
    HttpRequestBuilder& withUrl(const std::string& url) {
        // request_.setUrl(url);
        return *this;
    }
    HttpRequestBuilder& withMethod(const std::string& method) {
        // request_.setMethod(method);
        return *this;
    }
    HttpRequestBuilder& addHeader(const std::string& key, const std::string& value) {
        // request_.addHeader(key, value);
        return *this;
    }
    HttpRequestBuilder& setBody(const std::string& body)