C++建造者模式（Builder）

我们通过一个通俗易懂的日常生活例子来讲解建造者模式（Builder Pattern）。

生活中的实际应用：制造汽车

假设你是一家汽车制造公司的负责人，你需要制造不同类型的汽车，比如经济型汽车、运动型汽车和豪华型汽车。每种汽车都有不同的部件，例如引擎、车轮和座椅。为了确保制造过程的灵活性和可扩展性，你希望将汽车的构建过程与其具体表示分离开来，这样同样的构建过程可以创建不同类型的汽车。

主要角色

1. 建造者接口（Builder）：定义创建汽车部件的抽象接口。
2. 具体建造者（ConcreteBuilder）：实现建造者接口，具体构建不同类型的汽车。
3. 指导者（Director）：负责按照特定的步骤来构建汽车。
4. 产品（Product）：表示最终建造的汽车对象。

编码示例

下面的代码使用建造者模式来实现汽车制造过程。

#include <iostream>
#include <string>

// 产品类，表示最终建造的汽车
class Car {
private:
    std::string engine;
    std::string wheels;
    std::string seats;

public:
    void setEngine(const std::string& engine) {
        this->engine = engine;
    }

    void setWheels(const std::string& wheels) {
        this->wheels = wheels;
    }

    void setSeats(const std::string& seats) {
        this->seats = seats;
    }

    void show() {
        std::cout << "汽车配置: 引擎- " << engine << ", 车轮- " << wheels << ", 座椅- " << seats << std::endl;
    }
};

// 抽象建造者接口，定义创建汽车部件的接口
class CarBuilder {
public:
    virtual ~CarBuilder() {}
    virtual void buildEngine() = 0;
    virtual void buildWheels() = 0;
    virtual void buildSeats() = 0;
    virtual Car* getCar() = 0;
};

// 具体建造者类，构建经济型汽车
class EconomyCarBuilder : public CarBuilder {
private:
    Car* car;

public:
    EconomyCarBuilder() {
        this->car = new Car();
    }

    ~EconomyCarBuilder() {
        delete car;
    }

    void buildEngine() override {
        car->setEngine("经济型引擎");
    }

    void buildWheels() override {
        car->setWheels("经济型车轮");
    }

    void buildSeats() override {
        car->setSeats("经济型座椅");
    }

    Car* getCar() override {
        return this->car;
    }
};

// 具体建造者类，构建运动型汽车
class SportsCarBuilder : public CarBuilder {
private:
    Car* car;

public:
    SportsCarBuilder() {
        this->car = new Car();
    }

    ~SportsCarBuilder() {
        delete car;
    }

    void buildEngine() override {
        car->setEngine("运动型引擎");
    }

    void buildWheels() override {
        car->setWheels("运动型车轮");
    }

    void buildSeats() override {
        car->setSeats("运动型座椅");
    }

    Car* getCar() override {
        return this->car;
    }
};

// 指导者类，负责按步骤建造汽车
class Director {
private:
    CarBuilder* builder;

public:
    Director(CarBuilder* builder) {
        this->builder = builder;
    }

    void construct() {
        builder->buildEngine();
        builder->buildWheels();
        builder->buildSeats();
    }
};

// 主函数
int main() {
    // 创建经济型汽车建造者
    EconomyCarBuilder economyCarBuilder;
    Director director1(&economyCarBuilder);

    // 按照步骤构建经济型汽车
    director1.construct();
    Car* economyCar = economyCarBuilder.getCar();
    economyCar->show();
    
    // 创建运动型汽车建造者
    SportsCarBuilder sportsCarBuilder;
    Director director2(&sportsCarBuilder);

    // 按照步骤构建运动型汽车
    director2.construct();
    Car* sportsCar = sportsCarBuilder.getCar();
    sportsCar->show();

    return 0;
}

代码解释

1. 产品类 (Car)：表示最终建造的汽车对象，包含汽车的不同部件（引擎、车轮、座椅）的设置方法和显示方法。
2. 抽象建造者接口 (CarBuilder)：定义了创建汽车部件的抽象接口，包括 buildEngine()、buildWheels() 和 buildSeats() 方法，以及获取汽车对象的 getCar() 方法。
3. 具体建造者类 (EconomyCarBuilder 和 SportsCarBuilder)：分别实现抽象建造者接口，具体构建经济型汽车和运动型汽车。
4. 指导者类 (Director)：负责按照特定的步骤建造汽车，使用建造者接口中的方法来构建产品。
5. 主函数：创建具体建造者对象和指导者对象，按照顺序调用建造者的构建方法来创建不同类型的汽车，然后显示其配置。

总结

建造者模式的主要优点包括：

• 分离复杂对象的构建和表示：使得同样的构建过程可以创建不同的表示。
• 更多的灵活性和可扩展性：构建过程可以针对不同的需求进行定制。
• 提升代码可读性和维护性：针对复杂对象的创建逻辑进行了封装和抽象，使代码更加清晰。