建造者模式 (Builder Pattern)

建造者模式 (Builder Pattern)

意图：将复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。

基础组件

• Product (产品)：最终构建的复杂对象
• Builder (抽象建造者)：定义创建产品各部分的接口
• ConcreteBuilder (具体建造者)：实现Builder接口，提供具体实现
• Director (指挥者)：控制构建过程

继承/实现关系

Builder <|-- ConcreteBuilder
Director --> Builder (使用)
ConcreteBuilder --> Product (构建)

应用场景

• 需要创建具有多个组成部分的复杂对象
• 创建过程需要不同的配置
• 需要隔离复杂对象的创建和使用

C++ 实现（电脑组装场景）

#include <iostream>
#include <string>

/*
* 建造者模式
* 意图：将复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。
* 基础组件：
* - Product (产品)：最终构建的复杂对象
* - Builder (抽象建造者)：定义创建产品各部分的接口
* - ConcreteBuilder (具体建造者)：实现Builder接口，提供具体实现
* - Director (指挥者)：控制构建过程
* 继承/实现关系：
* ConcreteBuilder继承自Builder，Director使用Builder接口来构建产品。
* ConcreteBuilder实现了具体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 show() const {
        std::cout << "Computer Configuration:\n"
            << " CPU: " << cpu_ << "\n"
            << " RAM: " << ram_ << "\n"
            << " Storage: " << storage_ << "\n"
            << " GPU: " << gpu_ << "\n";
    }

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

// 抽象建造者，需要返回具体产品的结果
class ComputerBuilder {
public:
    virtual ~ComputerBuilder() = default;
    virtual void buildCPU() = 0;
    virtual void buildRAM() = 0;
    virtual void buildStorage() = 0;
    virtual void buildGPU() = 0;
    virtual Computer getResult() = 0;
};

// 具体建造者：游戏电脑
class GamingComputerBuilder : public ComputerBuilder {
public:
    void buildCPU() override { computer_.setCPU("Intel i9-13900K"); }
    void buildRAM() override { computer_.setRAM("32GB DDR5"); }
    void buildStorage() override { computer_.setStorage("2TB NVMe SSD"); }
    void buildGPU() override { computer_.setGPU("RTX 4090"); }
    Computer getResult() override { return computer_; }

private:
    Computer computer_;
};

// 具体建造者：办公电脑
class OfficeComputerBuilder : public ComputerBuilder {
public:
    void buildCPU() override { computer_.setCPU("Intel i5-12400"); }
    void buildRAM() override { computer_.setRAM("16GB DDR4"); }
    void buildStorage() override { computer_.setStorage("512GB SSD"); }
    void buildGPU() override { computer_.setGPU("Integrated"); }
    Computer getResult() override { return computer_; }

private:
    Computer computer_;
};

// 指挥者，负责控制建造过程
class ComputerDirector {
public:
    void setBuilder(ComputerBuilder* builder) { builder_ = builder; }

    void constructComputer() {
		std::cout << "Building computer...\n";
        builder_->buildCPU();
        builder_->buildRAM();
        builder_->buildStorage();
        builder_->buildGPU();
		std::cout << "Computer built successfully.\n";
    }

private:
    ComputerBuilder* builder_;
};


void BuilderPattern()
{
	std::cout << std::string(13, '-') << " Builder Pattern " << std::string(13, '-') << std::endl;
	GamingComputerBuilder gamingBuilder;
	OfficeComputerBuilder officeBuilder;
	ComputerDirector director;

	director.setBuilder(&gamingBuilder);
	director.constructComputer();
	Computer gamingComputer = gamingBuilder.getResult();
	gamingComputer.show();

	director.setBuilder(&officeBuilder);
	director.constructComputer();
	Computer officeComputer = officeBuilder.getResult();
	officeComputer.show();
}

组件对应关系

• Computer → 产品
• ComputerBuilder → 抽象建造者
• GamingComputerBuilder/OfficeComputerBuilder → 具体建造者
• ComputerDirector → 指挥者