建造者模式详解：原理及示例代码、结构图、使用场景及优缺点-优快云博客

#include <iostream>
#include <string>

// 产品类
class Pizza {
public:
    void setDough(const std::string& dough) {
        m_dough = dough;
    }
    void setSauce(const std::string& sauce) {
        m_sauce = sauce;
    }
    void setTopping(const std::string& topping) {
        m_topping = topping;
    }
    void open() const {
        std::cout << "Pizza with " << m_dough << " dough, " << m_sauce << " sauce and " << m_topping << " topping. Mmm!" << std::endl;
    }
private:
    std::string m_dough;
    std::string m_sauce;
    std::string m_topping;
};

// 抽象建造者
class PizzaBuilder {
public:
    virtual ~PizzaBuilder() {}
    Pizza* getPizza() {
        return m_pizza;
    }
    void createNewPizza() {
        m_pizza = new Pizza();
    }
    virtual void buildDough() = 0;
    virtual void buildSauce() = 0;
    virtual void buildTopping() = 0;
protected:
    Pizza* m_pizza;
};

// 具体建造者
class HawaiianPizzaBuilder : public PizzaBuilder {
public:
    virtual void buildDough() override {
        m_pizza->setDough("cross");
    }
    virtual void buildSauce() override {
        m_pizza->setSauce("mild");
    }
    virtual void buildTopping() override {
        m_pizza->setTopping("ham+pineapple");
    }
};

class SpicyPizzaBuilder : public PizzaBuilder {
public:
    virtual void buildDough() override {
        m_pizza->setDough("pan baked");
    }
    virtual void buildSauce() override {
        m_pizza->setSauce("hot");
    }
    virtual void buildTopping() override {
        m_pizza->setTopping("pepperoni+salami");
    }
};

// 指挥者
class Cook {
public:
    void setPizzaBuilder(PizzaBuilder* pb) {
        m_pizzaBuilder = pb;
    }
    Pizza* getPizza() {
        return m_pizzaBuilder->getPizza();
    }
    void constructPizza() {
        m_pizzaBuilder->createNewPizza();
        m_pizzaBuilder->buildDough();
        m_pizzaBuilder->buildSauce();
        m_pizzaBuilder->buildTopping();
    }
private:
    PizzaBuilder* m_pizzaBuilder;
};

int main() {
    Cook cook;
    HawaiianPizzaBuilder hawaiianPizzaBuilder;
    SpicyPizzaBuilder spicyPizzaBuilder;

    cook.setPizzaBuilder(&hawaiianPizzaBuilder);
    cook.constructPizza();

    Pizza* hawaiianPizza = cook.getPizza();
    hawaiianPizza->open();

    cook.setPizzaBuilder(&spicyPizzaBuilder);
    cook.constructPizza();

    Pizza* spicyPizza = cook.getPizza();
    spicyPizza->open();

    delete hawaiianPizza;
    delete spicyPizza;

    return 0;
}

在这个示例中，Pizza类是产品类，PizzaBuilder是抽象建造者，HawaiianPizzaBuilder和SpicyPizzaBuilder是具体建造者，Cook是指挥者。通过使用建造者模式，我们可以逐步构建不同类型的披萨对象，而不需要了解具体的构建细节。

二、结构图

建造者模式的结构图通常包括以下几个要素：

产品（Product）：要创建的复杂对象。
抽象建造者（Builder）：定义了创建产品各个部件的抽象接口。
具体建造者（ConcreteBuilder）：实现了抽象建造者接口，负责具体的产品部件的创建。
指挥者（Director）：负责使用建造者来构建产品对象。

下面是建造者模式的结构图示例：

+-------------------+              +------------------+
|      Product      |              |    Builder       |
+-------------------+              +------------------+
|                   |              | + createProduct()|
|                   |              | + buildPartA()   |
|                   |              | + buildPartB()   |
|                   |              | + buildPartC()   |
+---------+---------+              +--------+---------+
          |                                  |
          |                                  |
          |                                  |
          |                                  |
+---------+---------+              +--------+---------+
|ConcreteProduct   |              | ConcreteBuilder |
+-------------------+              +------------------+
|                   |              | + buildPartA()   |
|                   |              | + buildPartB()   |
|                   |              | + buildPartC()   |
+-------------------+              +--------+---------+
                                                  |
                                                  |
                                                  |
                                                  |
                                          +-------+---------+
                                          |   Director    |
                                          +---------------+
                                          | + construct() |
                                          +---------------+

在这个结构图中，产品（Product）是要创建的复杂对象，抽象建造者（Builder）定义了创建产品各个部件的抽象接口。具体建造者（ConcreteBuilder）实现了抽象建造者接口，负责具体的产品部件的创建。指挥者（Director）负责使用建造者来构建产品对象。

三、使用场景

建造者模式通常适用于以下场景：

当创建复杂对象的构造过程需要独立于其表示时，可以使用建造者模式。这意味着构造过程可以有不同的表示，而客户端代码无需关心具体的构造细节。
当一个对象的构造过程具有多个步骤，并且不同的构造步骤可以产生不同的表示时，建造者模式是一个很好的选择。通过使用建造者模式，可以将构造过程的每个步骤进行解耦，以便可以灵活地组合这些步骤来构建不同的对象表示。
当需要创建的对象具有复杂的内部结构，但客户端代码只关心最终的产品对象时，建造者模式可以隐藏对象的内部构造细节，使客户端代码更加简洁。
当创建对象的过程中涉及到可选的部件时，可以使用建造者模式。建造者模式可以方便地处理可选部件的构造和组合，而不需要创建大量的构造方法重载。

总之，建造者模式适用于需要创建复杂对象，且希望将构造过程与表示分离的情况。它可以帮助我们更好地组织对象的构造过程，使得代码更加灵活、可维护和可扩展。