大话设计模式之建造者模式

建造者模式（Builder Pattern）是一种创建型设计模式，旨在通过将复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。

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

Director（指挥者）：负责使用构建者对象构建产品对象的方法，而不直接参与产品的构建过程。可以理解为客户端与具体构建过程之间的桥梁。
Builder（抽象建造者）：定义了构建产品各个部件的抽象方法，具体的构建过程由具体的建造者来实现。
ConcreteBuilder（具体建造者）：实现了抽象建造者接口，负责实际构建产品各个部件并组装成最终产品。
Product（产品）：要创建的复杂对象，通常由多个部件组成。

#include <iostream>
#include <string>

// 产品类
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 showPizza() {
        std::cout << "Pizza with Dough: " << dough_ << ", Sauce: " << sauce_
                  << ", Topping: " << topping_ << std::endl;
    }

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

// 抽象建造者类
class PizzaBuilder {
public:
    virtual void buildDough() = 0;
    virtual void buildSauce() = 0;
    virtual void buildTopping() = 0;
    virtual Pizza* getPizza() = 0;
};

// 具体建造者类
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");
    }

    Pizza* getPizza() override {
        return pizza_;
    }

    HawaiianPizzaBuilder() {
        pizza_ = new Pizza();
    }

private:
    Pizza* pizza_;
};

// 具体建造者类
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");
    }

    Pizza* getPizza() override {
        return pizza_;
    }

    SpicyPizzaBuilder() {
        pizza_ = new Pizza();
    }

private:
    Pizza* pizza_;
};

// 指挥者类
class Waiter {
public:
    void setPizzaBuilder(PizzaBuilder* pb) {
        pizzaBuilder_ = pb;
    }

    Pizza* getPizza() {
        return pizzaBuilder_->getPizza();
    }

    void constructPizza() {
        pizzaBuilder_->buildDough();
        pizzaBuilder_->buildSauce();
        pizzaBuilder_->buildTopping();
    }

private:
    PizzaBuilder* pizzaBuilder_;
};

int main() {
    Waiter waiter;

    HawaiianPizzaBuilder hawaiianPizzaBuilder;
    waiter.setPizzaBuilder(&hawaiianPizzaBuilder);
    waiter.constructPizza();
    Pizza* hawaiianPizza = waiter.getPizza();
    hawaiianPizza->showPizza();

    SpicyPizzaBuilder spicyPizzaBuilder;
    waiter.setPizzaBuilder(&spicyPizzaBuilder);
    waiter.constructPizza();
    Pizza* spicyPizza = waiter.getPizza();
    spicyPizza->showPizza();

    delete hawaiianPizza;
    delete spicyPizza;

    return 0;
}

/*
在这个例子中，我们有一个 Pizza 类作为产品类，定义了 Pizza 的属性和展示方法。
然后定义了抽象建造者类 PizzaBuilder，包含了构建 Pizza 各个部件的抽象方法。
接着定义了两个具体建造者类 HawaiianPizzaBuilder 和 SpicyPizzaBuilder，
分别实现了构建不同类型 Pizza 的方法。最后是指挥者类 Waiter，负责指导具体建造者构建 Pizza。
在 main 函数中，我们可以看到通过指挥者指导具体建造者构建 Pizza，
并最终展示出不同类型的 Pizza。
*/

觉得有帮助的话，打赏一下呗。。