C++ 设计模式：建造者模式（Builder Pattern）

链接：C++ 设计模式
链接：C++ 设计模式 - 工厂方法
链接：C++ 设计模式 - 抽象工厂
链接：C++ 设计模式 - 原型模式

建造者模式（Builder Pattern）是一种创建型设计模式，它允许你分步骤创建复杂对象。与其他创建型模式不同，建造者模式不仅关注对象的创建，还关注对象的组装过程。

1.问题分析

在软件开发中，有时我们需要创建一个复杂对象，这个对象由多个部分组成，并且这些部分的构建过程可能非常复杂。直接使用构造函数来创建这样的对象会导致代码难以维护和扩展。建造者模式通过将对象的构建过程与表示分离，使得同样的构建过程可以创建不同的表示。

2.实现步骤

定义产品类：定义一个复杂对象类，该类包含多个部分。
定义建造者接口：定义一个包含构建各个部分方法的接口。
实现具体建造者类：实现建造者接口，提供构建各个部分的具体实现。
定义指挥者类：定义一个指挥者类，用于控制建造过程。
客户端代码：使用指挥者类和具体建造者类来创建复杂对象。

3.代码示例

3.1.定义产品类

// 机器人类
class Robot {
 public:
  void setHead(const std::string& head) { head_ = head; }
  void setBody(const std::string& body) { body_ = body; }
  void setArms(const std::string& arms) { arms_ = arms; }
  void setLegs(const std::string& legs) { legs_ = legs; }

  void show() const { std::cout << "Robot Parts: " << head_ << ", " << body_ << ", " << arms_ << ", " << legs_ << std::endl; }

 private:
  std::string head_;
  std::string body_;
  std::string arms_;
  std::string legs_;
};

3.2.定义建造者接口

// 建造者接口
class RobotBuilder {
 public:
  virtual ~RobotBuilder() = default;
  virtual void buildHead() = 0;
  virtual void buildBody() = 0;
  virtual void buildArms() = 0;
  virtual void buildLegs() = 0;
  virtual std::unique_ptr<Robot> getResult() = 0;

 protected:
  std::unique_ptr<Robot> robot_ = std::make_unique<Robot>();
};

3.3.实现具体建造者类

// 清洁机器人建造者类
class CleaningRobotBuilder : public RobotBuilder {
 public:
  void buildHead() override { robot_->setHead("Cleaning Head"); }
  void buildBody() override { robot_->setBody("Cleaning Body"); }
  void buildArms() override { robot_->setArms("Cleaning Arms"); }
  void buildLegs() override { robot_->setLegs("Cleaning Legs"); }

  std::unique_ptr<Robot> getResult() override { return std::move(robot_); }
};

// 巡检机器人建造者类
class InspectionRobotBuilder : public RobotBuilder {
 public:
  void buildHead() override { robot_->setHead("Inspection Head"); }
  void buildBody() override { robot_->setBody("Inspection Body"); }
  void buildArms() override { robot_->setArms("Inspection Arms"); }
  void buildLegs() override { robot_->setLegs("Inspection Legs"); }

  std::unique_ptr<Robot> getResult() override { return std::move(robot_); }
};

3.4.定义指挥者类

// 指挥者类
class RobotDirector {
 public:
  void setBuilder(RobotBuilder* builder) { builder_ = builder; }

  std::unique_ptr<Robot> construct() {
    builder_->buildHead();
    builder_->buildBody();
    builder_->buildArms();
    builder_->buildLegs();
    return builder_->getResult();
  }

 private:
  RobotBuilder* builder_;
};

3.5.客户端代码

int main() {
  // 创建具体建造者对象
  CleaningRobotBuilder cleaningBuilder;
  InspectionRobotBuilder inspectionBuilder;

  // 创建指挥者对象并设置建造者
  RobotDirector director;

  // 构建清洁机器人
  director.setBuilder(&cleaningBuilder);
  std::unique_ptr<Robot> cleaningRobot = director.construct();
  cleaningRobot->show();

  // 构建巡检机器人
  director.setBuilder(&inspectionBuilder);
  std::unique_ptr<Robot> inspectionRobot = director.construct();
  inspectionRobot->show();

  return 0;
}

4.总结

建造者模式（Builder Pattern）
1. 创建过程：指挥者控制对象的创建过程，按特定顺序构建对象。
2. 目的：将复杂对象的构建过程与其表示分离。
3. 适用场景：
  - 需要逐步构建复杂对象，并且构建过程可以有不同的表示。
  - 对象由多个部分组成，每个部分可以独立构建。
  - 需要控制对象的创建过程。
工厂模式（Factory Pattern）
1. 创建过程：工厂决定创建哪个具体对象，创建过程较为简单。
2. 目的：定义一个用于创建对象的接口，让子类决定实例化哪一个类。
3. 适用场景：
  - 需要创建的对象类型在运行时才确定。
  - 需要将对象的创建与使用分离。
  - 对象通常是一个整体，创建时不需要逐步构建。