C++建造者模式怎么应用 复杂对象分步构建过程

#include <iostream>
#include <string>
#include <memory> // 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<Computer> getComputer() = 0;
};

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

public:
    GamingComputerBuilder() : computer_(std::make_unique<Computer>()) {}

    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<Computer> getComputer() override {
        return std::move(computer_); // 返回所有权，并重置内部指针
    }
};

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

public:
    OfficeComputerBuilder() : computer_(std::make_unique<Computer>()) {}

    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<Computer> 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<Computer> gamingComputer = gamingBuilder.getComputer();
    if (gamingComputer) {
        gamingComputer->showConfiguration();
    }

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

    return 0;
}
*/

// 伪代码，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)