设计模式——建造者模式

建造者模式是一种创建型设计模式，用于构建一个复杂对象的创建过程与其表示分离。它允许你逐步构造一个复杂对象，而不需要一次性定义其所有属性。这种模式的关键是将构造过程与最终对象分离，使得相同的构造过程可以创建不同的表示。

建造者模式的实现原理是将一个复杂对象的构建过程分解为多个步骤，然后通过一个指导者类来逐步指导构建，最终得到完整的对象。这种方式将构建过程与表示分离，使得相同的构建过程可以创建不同的表示。

在建造者模式中，通常有以下几个角色：

产品类（Product）：表示被构建的复杂对象，包含多个部件。
抽象建造者类（Builder）：定义了构建产品的抽象接口，包括构建各个部件的方法。
具体建造者类（Concrete Builder）：实现了抽象建造者接口，负责具体的构建过程。
指导者类（Director）：负责指导构建过程，通常通过指定具体的建造者来构建对象。

下面是一个简单的示例：

#include <iostream>
#include <string>
#include <memory>

// Product class
class Pizza {
public:
    void setDough(const std::string& dough) {
        dough_ = dough;
    }

    void setSauce(const std::string& sauce) {
        sauce_ = sauce;
    }

    void setTopping(const std::string& topping) {
        topping_ = topping;
    }

    void display() const {
        std::cout << "Pizza with dough: " << dough_ << ", sauce: " << sauce_ << ", topping: " << topping_ << std::endl;
    }

private:
    std::string dough_;
    std::string sauce_;
    std::string topping_;
};

// Builder interface
class PizzaBuilder {
public:
    virtual void buildDough() = 0; // 构建面团
    virtual void buildSauce() = 0; // 构建酱料
    virtual void buildTopping() = 0; // 构建配料
    virtual std::unique_ptr<Pizza> getPizza() = 0; // 获取构建好的 Pizza 对象
    virtual ~PizzaBuilder() = default;
};

// Concrete builder 1
class HawaiianPizzaBuilder : public PizzaBuilder {
public:
    void buildDough() override {
        pizza_->setDough("cross");
    }

    void buildSauce() override {
        pizza_->setSauce("mild");
    }

    void buildTopping() override {
        pizza_->setTopping("ham and pineapple");
    }

    std::unique_ptr<Pizza> getPizza() override {
        return std::move(pizza_);
    }

private:
    std::unique_ptr<Pizza> pizza_ = std::make_unique<Pizza>();
};

// Concrete builder 2
class SpicyPizzaBuilder : public PizzaBuilder {
public:
    void buildDough() override {
        pizza_->setDough("pan baked");
    }

    void buildSauce() override {
        pizza_->setSauce("hot");
    }

    void buildTopping() override {
        pizza_->setTopping("pepperoni and salami");
    }

    std::unique_ptr<Pizza> getPizza() override {
        return std::move(pizza_);
    }

private:
    std::unique_ptr<Pizza> pizza_ = std::make_unique<Pizza>();
};

// Director
class Cook {
public:
    void setPizzaBuilder(std::unique_ptr<PizzaBuilder> builder) {
        builder_ = std::move(builder);
    }

    void constructPizza() {
        builder_->buildDough(); // 构建面团
        builder_->buildSauce(); // 构建酱料
        builder_->buildTopping(); // 构建配料
    }

    std::unique_ptr<Pizza> getPizza() {
        return builder_->getPizza(); // 获取构建好的 Pizza 对象
    }

private:
    std::unique_ptr<PizzaBuilder> builder_;
};

int main() {
    Cook cook;
    
    // Prepare Hawaiian pizza
    std::unique_ptr<PizzaBuilder> hawaiianBuilder = std::make_unique<HawaiianPizzaBuilder>();
    cook.setPizzaBuilder(std::move(hawaiianBuilder));
    cook.constructPizza();
    std::unique_ptr<Pizza> hawaiianPizza = cook.getPizza();
    hawaiianPizza->display();

    // Prepare Spicy pizza
    std::unique_ptr<PizzaBuilder> spicyBuilder = std::make_unique<SpicyPizzaBuilder>();
    cook.setPizzaBuilder(std::move(spicyBuilder));
    cook.constructPizza();
    std::unique_ptr<Pizza> spicyPizza = cook.getPizza();
    spicyPizza->display();

    return 0;
}

我们通过抽象建造者类 PizzaBuilder 定义了构建产品的抽象接口，具体的建造者类 HawaiianPizzaBuilder 和 SpicyPizzaBuilder 实现了这些接口来完成具体的构建过程。指导者类 Cook 负责指导构建过程，并在需要时指定具体的建造者。