C++设计模式-构建器 Builder

//Build 模式是一种创建复杂对象的设计模式，它通过将创建对象的过程分解为多个简单步骤，并使用一个 Builder 类来组合这些步骤，最终创建出一个完整的对象。Build 模式可以有效地隐藏对象的复杂构建过程，从而简化客户端代码，提高代码复用性。
//
//以下是一个简单的 C++ Build 模式示例，用于创建一个复杂的产品对象：
//
//```c+ +
#include <iostream>
#include <string>

class Product {
private:
    std::string partA;
    std::string partB;
    std::string partC;
public:
    void setPartA(std::string a) {
        partA = a;
    }
    void setPartB(std::string b) {
        partB = b;
    }
    void setPartC(std::string c) {
        partC = c;
    }
    void show() {
        std::cout << "Product: " << partA << " - " << partB << " - " << partC << std::endl;
    }
};

class Builder {
public:
    virtual void buildPartA() = 0;
    virtual void buildPartB() = 0;
    virtual void buildPartC() = 0;
    virtual Product getProduct() = 0;
};

class ConcreteBuilder : public Builder {
private:
    Product product;
public:
    void buildPartA() {
        product.setPartA("PartA");
    }
    void buildPartB() {
        product.setPartB("PartB");
    }
    void buildPartC() {
        product.setPartC("PartC");
    }
    Product getProduct() {
        return product;
    }
};

class Director {
private:
    Builder* builder;
public:
    Director(Builder* builder) {
        this->builder = builder;
    }
    void construct() {
        builder->buildPartA();
        builder->buildPartB();
        builder->buildPartC();
    }
};

int main() {
    ConcreteBuilder builder;
    Director director(&builder);
    director.construct();
    Product product = builder.getProduct();
    product.show();
    return 0;
}
//```
//
//在上面的示例中：
//
//- `Product` 类定义了复杂产品对象，并提供了一些设置和显示方法。
//- `Builder` 类定义了抽象构建器接口，包括创建每个部分的方法和获取最终产品的方法。
//- `ConcreteBuilder` 类实现了 `Builder` 接口，并定义了构建产品对象的具体步骤。
//- `Director` 类负责使用构建器对象并控制产品对象的构建过程。
//
//在 `main` 函数内，我们创建一个 `ConcreteBuilder` 对象并将其传递给 `Director` 对象。
// 然后我们调用 `Director` 对象的 `construct()` 方法来构建产品对象。
// 最终，我们通过 `ConcreteBuilder` 对象的 `getProduct()` 方法获取产品对象，
// 并调用其 `show()` 方法来显示产品信息。
//
//这个示例中使用了 Build 模式来创建一个复杂对象，并将其构建过程分解为多个简单步骤。
//这种方式可以有效地隐藏了对象构建的复杂性，并提高了代码的可维护性和复用性。