建造者模式

在C++中，建造者模式是一种设计模式，它提供了一种方法来分离对象的构建过程和它的表示，使得同样的构建过程可以创建不同的表示。

建造者模式通常包括以下几个角色：

• Builder：抽象建造者，定义了用于构建对象各个部分的抽象接口。

• ConcreteBuilder：具体建造者，实现了Builder接口，提供了具体的构建逻辑。

• Director：指挥者，负责使用Builder接口构建对象。

• Product：产品，表示被构建的对象。

class Product {
public:
  virtual ~Product() {}
  virtual void operationA() = 0;
  virtual void operationB() = 0;
  virtual void operationC() = 0;
};

class ConcreteProduct : public Product {
public:
  void operationA() override {
    // ...
  }
  void operationB() override {
    // ...
  }
  void operationC() override {
    // ...
  }
};

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

class ConcreteBuilder : public Builder {
public:
  void buildPartA() override {
    // ...
  }
  void buildPartB() override {
    // ...
  }
  void buildPartC() override {
    // ...
  }
  Product* getProduct() override {
    return product_;
  }

private:
  ConcreteProduct* product_;
};

class Director {
public:
  void setBuilder(Builder* builder) {
    builder_ = builder;
  }
  void build() {
    builder_->buildPartA();
    builder_->buildPartB();
    builder_->buildPartC();
  }

private:
  Builder* builder_;
};

int main() {
  Director director;
  ConcreteBuilder builder;

  director.setBuilder(&builder);
  director.build();

  Product* product = builder.getProduct();
  product->operationA();
  product->operationB();
  product->operationC();

  delete product;

  return 0;
}

建造者模式的优点：

• 可以使得构建过程与表示分离，从而使得同样的构建过程可以创建不同的表示。
• 可以使用不同的具体建造者来构建不同的产品。
• 可以使用指挥者来控制构建过程。

建造者模式的缺点：

• 实现建造者模式可能会比较复杂。
• 如果产品的内部发生变化，那么需要修改所有的具体建造者。

 示例：

定义一个汽车类型，包括汽车的型号、颜色、轮胎数量和引擎类型，并提供了一个建造者来创建汽车对象；

#include <iostream>
#include <string>

class Car {
 public:
  std::string model;
  std::string color;
  int numWheels;
  std::string engineType;

  void setModel(std::string model) {
    this->model = model;
  }

  void setColor(std::string color) {
    this->color = color;
  }

  void setNumWheels(int numWheels) {
    this->numWheels = numWheels;
  }

  void setEngineType(std::string engineType) {
    this->engineType = engineType;
  }
};

class CarBuilder {
 protected:
  Car car;

 public:
  CarBuilder() {}

  Car* getCar() {
    return &car;
  }
};

class SedanCarBuilder : public CarBuilder {
 public:
  SedanCarBuilder() {
    car.setNumWheels(4);
    car.setEngineType("V6");
  }

  void setModel(std::string model) {
    car.setModel(model);
  }

  void setColor(std::string color) {
    car.setColor(color);
  }
};

class SUVCarBuilder : public CarBuilder {
 public:
  SUVCarBuilder() {
    car.setNumWheels(4);
    car.setEngineType("V8");
  }

  void setModel(std::string model) {
    car.setModel(model);
  }

  void setColor(std::string color) {
    car.setColor(color);
  }
};

class CarDirector {
 private:
  CarBuilder* builder;

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

  Car* getCar() {
    return builder->getCar();
  }

  void buildCar() {
    builder->setModel("Model X");
    builder->setColor("Red");
  }
};

int main() {
  CarDirector director;
  CarBuilder* builder = new SedanCarBuilder();
  director.setBuilder(builder);
  director.buildCar();
  Car* car = director.getCar();

  std::cout << "Model: " << car->model << std::endl;
  std::cout << "Color: " << car->color << std::endl;
  std::cout << "Num wheels: " << car->numWheels << std::endl;
  std::cout << "Engine type: " << car->engineType<< std::endl;
}