it 网站模板今日新闻最新消息

动机

在软件系统中，有时候面临着“一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。

如何应对这种变化？如何提供一种“封装机制”来隔离出“复杂对象的各个部分”的变化，从而保持系统中的“稳定构建算法”不随着需求改变而改变？

代码示例：建立各种房子，比如砖瓦房，高楼，别墅等房子

class House{//....
};class HouseBuilder {
public:House* GetResult(){return pHouse;}virtual ~HouseBuilder(){}
protected:House* pHouse;virtual void BuildPart1()=0;virtual void BuildPart2()=0;virtual void BuildPart3()=0;virtual void BuildPart4()=0;virtual void BuildPart5()=0;};class StoneHouse: public House{};// 石头房子的创建，override HouseBuilder里面的流程
class StoneHouseBuilder: public HouseBuilder{
protected:virtual void BuildPart1(){//pHouse->Part1 = ...;}virtual void BuildPart2(){}virtual void BuildPart3(){}virtual void BuildPart4(){}virtual void BuildPart5(){}};// 房子具体构建过程
class HouseDirector{public:// 有一个HouseBuilder的指针HouseBuilder* pHouseBuilder;HouseDirector(HouseBuilder* pHouseBuilder){this->pHouseBuilder=pHouseBuilder;}House* Construct(){ // 整个构建流程是稳定的pHouseBuilder->BuildPart1();for (int i = 0; i < 4; i++){pHouseBuilder->BuildPart2();}bool flag=pHouseBuilder->BuildPart3();if(flag){pHouseBuilder->BuildPart4();}pHouseBuilder->BuildPart5();return pHouseBuilder->GetResult();}
};int main() {// 创建石头房子的建造者StoneHouseBuilder stoneHouseBuilder;// 创建房子Director，并指定建造者HouseDirector houseDirector(&stoneHouseBuilder);// 构建房子House* stoneHouse = houseDirector.Construct();// 输出结果if (stoneHouse != nullptr) {// 假设 House 类有适当的输出方法// 这里只是简单示例，实际使用时需要根据具体类的实现调用相应的方法std::cout << "Stone House constructed." << std::endl;} else {std::cout << "Failed to construct Stone House." << std::endl;}// 释放资源delete stoneHouse;return 0;
}

上述代码涉及了Builder设计模式，包括以下几个类：

House 类:

表示待构建的产品，即房子。在示例中，StoneHouse 类是 House 的具体实现。

HouseBuilder 抽象类:

定义了构建产品（房子）的抽象接口。具体的建造者（例如 StoneHouseBuilder）需要继承这个抽象类并实现接口中的方法，以完成具体产品的构建。

StoneHouseBuilder 类:

是HouseBuilder的具体实现，负责构建石头房子。它通过实现抽象接口中的方法来完成具体的建造流程。

HouseDirector 类:

起到指导建造的作用，通过构造函数接收一个具体的建造者对象。通过调用建造者的方法，按照一定的构建流程组织建造者完成产品的构建。
main 函数:

在 main 函数中，创建了 StoneHouseBuilder 的实例，然后创建了一个HouseDirector的实例，并将建造者传递给导演。通过导演的 Construct 方法，按照一定的构建流程构建了石头房子，并输出结果。
总体而言，Builder设计模式的目的是将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。在这个示例中，HouseBuilder 抽象类定义了构建房子的接口，StoneHouseBuilder 实现了具体的石头房子构建流程，而 HouseDirector 则负责协调建造者完成整个构建流程。

Builder要点总结

Builder 模式主要用于“分步骤构建一个复杂的对象”。在这其中“分步骤”是一个稳定的算法，而复杂对象的各个部分则经常变化。

变化点在哪里，封装哪里—— Builder模式主要在于应对“复杂对象各个部分”的频繁需求变动。其缺点在于难以应对“分步骤构建算法”的需求变动。

在Builder模式中，要注意不同语言中构造器内调用虚函数的差别（C++ vs. C#) 。

chatGPT给出的builder的例子

以下是一个简单的C++示例代码，演示Builder设计模式：

#include <iostream>
#include <string>// 产品类
class Product {
public:void AddPart(const std::string& part) {parts += part + " ";}void Show() const {std::cout << "Product Parts: " << parts << std::endl;}private:std::string parts;
};// 抽象建造者类
class Builder {
public:virtual void BuildPart1() = 0;virtual void BuildPart2() = 0;virtual Product* GetResult() = 0;
};// 具体建造者类
class ConcreteBuilder : public Builder {
public:ConcreteBuilder() {product = new Product();}void BuildPart1() override {product->AddPart("Part1");}void BuildPart2() override {product->AddPart("Part2");}Product* GetResult() override {return product;}private:Product* product;
};// 指导者类
class Director {
public:Director(Builder* builder) : builder(builder) {}void Construct() {builder->BuildPart1();builder->BuildPart2();}private:Builder* builder;
};int main() {// 创建具体建造者ConcreteBuilder concreteBuilder;// 创建指导者，并传入具体建造者Director director(&concreteBuilder);// 指导者构建产品director.Construct();// 获取最终产品Product* product = concreteBuilder.GetResult();// 展示产品if (product != nullptr) {product->Show();delete product;}return 0;
}

在这个示例中，Product 表示最终构建的复杂对象，Builder 是抽象建造者类，ConcreteBuilder 是具体建造者类，Director 是指导者类。通过指导者调用具体建造者的方法，最终得到构建完成的产品。这个例子中的产品是简单的包含两个部分的字符串，实际应用中可以根据需求定义更复杂的产品结构。