建造者设计模式

1、建造者设计模式概述：

建造者模式（Builder Pattern）是一种创建型设计模式，用于将复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。建造者模式涉及到多个步骤，通常由指挥者（Director）按照特定的顺序调用建造者（Builder）提供的方法，最后由建造者返回构建完成的对象。
建造者模式通常包含以下几个角色：

• 产品（Product）：表示需要构建的复杂对象。
• 建造者（Builder）：定义用于构建产品的接口，包括创建和组装各个部件的方法。
• 具体建造者（ConcreteBuilder）：实现 Builder
  接口，提供具体的创建和组装方法。每个具体建造者创建的产品可以有不同的表示。
• 指挥者（Director）：负责调用 Builder 提供的方法，按照特定的顺序构建产品。指挥者通常与 Builder
  之间解耦，使得可以使用不同的 Builder 创建不同的产品。

2、建造者设计模式的适用场景：

• 当创建一个复杂对象需要多个步骤，且步骤之间存在一定的顺序时，可以使用建造者模式。
• 当需要根据不同的配置或条件创建具有不同表示的对象时，可以使用建造者模式。
• 当需要将对象的构建过程与表示分离，以提高代码的复用性和可维护性时，可以使用建造者模式。

3、建造者设计模式的优点：

• 将复杂对象的构建过程与表示分离，降低了客户端与具体产品类之间的耦合，提高了代码的可维护性。
• 可以根据不同的需求创建具有不同表示的对象，提高了系统的灵活性。
• 当需要修改或新增产品时，只需修改或新增具体建造者，无需修改指挥者和客户端代码，符合开放封闭原则。

4、建造者设计模式的缺点：

• 建造者模式可能导致大量的类和接口，增加了系统的复杂性。
• 当产品种类较少，且构建过程简单时，使用建造者模式可能导致过度设计。

5、用C++语言实现一个建造者设计模式的例子：

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

class Product {
public:
    void addPart(const std::string& part) {
        parts += part + " ";
    }

    void show() {
        std::cout << "Product parts: " << parts << std::endl;
    }

private:
    std::string parts;
};

class Builder {
public:
    virtual ~Builder() = default;
    virtual void buildPartA() = 0;
	virtual void buildPartB() = 0;
	virtual std::unique_ptr<Product> getResult() = 0;
};

class ConcreteBuilder1 : public Builder {
public:
	ConcreteBuilder1() {
		product = std::make_unique<Product>();
	}
	void buildPartA() override {
    	product->addPart("PartA1");
	}

	void buildPartB() override {
    	product->addPart("PartB1");
	}

	std::unique_ptr<Product> getResult() override {
    	return std::move(product);
	}
private:
	std::unique_ptr<Product> product;
};

class ConcreteBuilder2 : public Builder {
public:
	ConcreteBuilder2() {
		product = std::make_unique<Product>();
	}
	void buildPartA() override {
   		product->addPart("PartA2");
	}

	void buildPartB() override {
    	product->addPart("PartB2");
	}

	std::unique_ptr<Product> getResult() override {
    	return std::move(product);
	}
private:
	std::unique_ptr<Product> product;
};

class Director {
public:
	void setBuilder(std::unique_ptr<Builder> builder) {
		this->builder = std::move(builder);
	}
	void construct() {
    	builder->buildPartA();
    	builder->buildPartB();
	}
private:
	std::unique_ptr<Builder> builder;
};

int main() {
	Director director;
	std::unique_ptr<Builder> builder1 = std::make_unique<ConcreteBuilder1>();
	director.setBuilder(std::move(builder1));
	director.construct();
	std::unique_ptr<Product> product1 = builder1->getResult();
	product1->show();
	std::unique_ptr<Builder> builder2 = std::make_unique<ConcreteBuilder2>();
	director.setBuilder(std::move(builder2));
	director.construct();
	std::unique_ptr<Product> product2 = builder2->getResult();
	product2->show();

	return 0;
}

在这个例子中，我们定义了一个 Product 类，它表示需要构建的复杂对象。接着，我们创建了一个 Builder 接口，以及两个具体建造者：ConcreteBuilder1 和 ConcreteBuilder2，它们分别实现了 Builder 接口的方法，用于创建和组装 Product 对象。然后，我们创建了一个 Director 类，它包含一个 Builder 对象，并负责按照特定的顺序调用 Builder 的方法来构建 Product 对象。最后，在 main 函数中，我们使用 Director 和不同的具体建造者创建了两个具有不同表示的 Product 对象，并调用了它们的 show 方法。