C++实现设计模式---建造者模式 (Builder)

建造者模式 (Builder)

建造者模式 是一种创建型设计模式，它将一个复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的表示。

---

意图

• 将复杂对象的创建过程分步骤完成，并允许以不同方式构建其各部分。
• 提供灵活的方式构造对象，而无需关心其内部细节。

---

使用场景

1. 创建复杂对象：
   • 当对象的创建需要很多步骤或参数时，使用建造者模式可以简化代码。
2. 需要多个构建版本：
   • 如同一个对象可能有不同的表示形式，但它们共享相同的构建过程。
3. 避免构造函数过长：
   • 当对象的初始化参数非常多时，可以使用建造者模式替代复杂的构造函数。

---

参与者角色

1. 建造者接口 (Builder)
   • 定义创建复杂对象各部分的接口。
2. 具体建造者 (Concrete Builder)
   • 实现 Builder 接口，构造并装配复杂对象的各个部分。
3. 指挥者 (Director)
   • 定义构建对象的顺序，指导建造者完成对象的创建。
4. 产品 (Product)
   • 表示被构建的复杂对象。

---

示例代码

以下示例展示了如何使用建造者模式创建复杂的 Car 对象。

#include 
#include 
#include 

// 产品类: 汽车
class Car {
private:
    std::string engine;
    std::string body;
    std::string wheels;

public:
    void setEngine(const std::string& eng) {
        engine = eng;
    }

    void setBody(const std::string& bod) {
        body = bod;
    }

    void setWheels(const std::string& whl) {
        wheels = whl;
    }

    void show() const {
        std::cout << "Car with engine: " << engine
                  << ", body: " << body
                  << ", wheels: " << wheels << std::endl;
    }
};

// 建造者接口
class CarBuilder {
public:
    virtual ~CarBuilder() {}
    virtual void buildEngine() = 0;
    virtual void buildBody() = 0;
    virtual void buildWheels() = 0;
    virtual std::shared_ptr<Car> getCar() = 0;
};

// 具体建造者: 运动型汽车
class SportsCarBuilder : public CarBuilder {
private:
    std::shared_ptr<Car> car;

public:
    SportsCarBuilder() {
        car = std::make_shared<Car>();
    }

    void buildEngine() override {
        car->setEngine("Sports Engine");
    }

    void buildBody() override {
        car->setBody("Sports Body");
    }

    void buildWheels() override {
        car->setWheels("Sports Wheels");
    }

    std::shared_ptr<Car> getCar() override {
        return car;
    }
};

// 具体建造者: 家用汽车
class FamilyCarBuilder : public CarBuilder {
private:
    std::shared_ptr<Car> car;

public:
    FamilyCarBuilder() {
        car = std::make_shared<Car>();
    }

    void buildEngine() override {
        car->setEngine("Family Engine");
    }

    void buildBody() override {
        car->setBody("Family Body");
    }

    void buildWheels() override {
        car->setWheels("Family Wheels");
    }

    std::shared_ptr<Car> getCar() override {
        return car;
    }
};

// 指挥者类
class Director {
public:
    void construct(CarBuilder& builder) {
        builder.buildEngine();
        builder.buildBody();
        builder.buildWheels();
    }
};

// 主函数
int main() {
    Director director;

    // 构建运动型汽车
    SportsCarBuilder sportsCarBuilder;
    director.construct(sportsCarBuilder);
    auto sportsCar = sportsCarBuilder.getCar();
    sportsCar->show(); // 输出: Car with engine: Sports Engine, body: Sports Body, wheels: Sports Wheels

    // 构建家用汽车
    FamilyCarBuilder familyCarBuilder;
    director.construct(familyCarBuilder);
    auto familyCar = familyCarBuilder.getCar();
    familyCar->show(); // 输出: Car with engine: Family Engine, body: Family Body, wheels: Family Wheels

    return 0;
}

---

代码解析

1. 产品类

• Car 是一个复杂对象，由多个部件（引擎、车身、车轮）组成。
• 提供方法 setEngine()、setBody() 和 setWheels() 用于设置部件。

2. 建造者接口

• 定义了构建产品各部分的方法，如 buildEngine()、buildBody() 和 buildWheels()。
• 定义 getCar() 方法返回构建完成的产品。

3. 具体建造者

• 不同建造者（如 SportsCarBuilder 和 FamilyCarBuilder）实现 CarBuilder 接口。
• 每个建造者提供不同的构建细节。

4. 指挥者

• Director 类负责控制建造的流程和顺序。
• 调用建造者的方法构造产品。

5. 客户端

• 客户端通过指挥者和建造者接口创建产品，而无需关心具体产品的构建细节。

---

优缺点

优点

1. 分离创建与表示：将复杂对象的构建逻辑与其表示分离。
2. 灵活性高：同样的构建步骤可以用于构造不同的对象。
3. 易于扩展：新增建造者或产品类型时，几乎不需要修改其他代码。

缺点

1. 增加复杂性：需要额外定义多个建造者类和指挥者类。
2. 不适合简单对象：对于简单对象的创建，使用建造者模式会显得过于冗长。

---

适用场景

• 创建复杂对象：如有多个部件需要组合，并且需要支持不同的组合方式。
• 避免构造函数混乱：如构造函数参数过多，使用建造者模式可以避免错误。

---

改进与扩展

1. 简化构建流程：
   可以省略 Director，让客户端直接调用建造者完成构建。
2. 结合 Fluent 接口：
   使用链式调用简化代码，使得建造流程更加流畅：

   auto car = CarBuilder()
       .setEngine("Sports Engine")
       .setBody("Sports Body")
       .setWheels("Sports Wheels")
       .build();
   

---

总结

建造者模式通过将对象的构建过程与其表示分离，使得复杂对象的创建更加灵活和可扩展。
它适用于需要创建复杂对象并支持多种表示形式的场景。