Builder(建造者模式)

1. 意图

建造者模式是一种创建型设计模式，它允许按照特定的步骤构建复杂对象。该模式将对象的构造过程与其表示分离，使得同样的构造过程可以创建不同的表示。

建造者模式将对象的构建过程与表示分离，使得同样的构建过程可以创建不同的表示。它适用于需要构建复杂对象的场景，并且可以灵活地组合和配置构建过程。

2. 适用性

当需要创建的对象具有复杂的内部结构，且创建过程需要多个步骤或条件时。
当希望将对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。
当希望构建过程可以灵活地组合和配置，以创建不同的对象。

3. 实现

cpp 复制代码

#include <iostream>
#include <string>

class Cpu {
public:
  virtual ~Cpu() {}
  std::string m_info;
};
class CpuA : public Cpu {
public:
  CpuA() : Cpu() { m_info = "CpuA"; }
};
class CpuB : public Cpu {
public:
  CpuB() : Cpu() { m_info = "CpuB"; }
};

class Memory {
public:
  virtual ~Memory() {}
  std::string m_info;
};
class MemoryA : public Memory {
public:
  MemoryA() : Memory() { m_info = "MemoryA"; }
};
class MemoryB : public Memory {
public:
  MemoryB() : Memory() { m_info = "MemoryB"; }
};

class Computer {
public:
  Computer() : m_cpu(nullptr), m_memory(nullptr) {}
  inline void SetCpu(Cpu *ptr) { m_cpu = ptr; }
  inline void SetMemory(Memory *ptr) { m_memory = ptr; }

  void Print() const {
    std::cout << "CpuInfo: " << m_cpu->m_info
              << ", MemoryInfo: " << m_memory->m_info << std::endl;
  }

private:
  Cpu *m_cpu;
  Memory *m_memory;
};

class Builder {
public:
  Builder() : m_computer(nullptr), m_cpu(nullptr), m_memory(nullptr) {
    m_computer = new Computer;
  }
  virtual ~Builder() {
    if (m_computer)
      delete m_computer;
    if (m_cpu)
      delete m_cpu;
    if (m_memory)
      delete m_memory;
  }
  virtual Computer *Create() = 0;
  virtual void BuildCpu() = 0;
  virtual void BuildMemory() = 0;

protected:
  Computer *m_computer;
  Cpu *m_cpu;
  Memory *m_memory;
};

class BuilderA : public Builder {
public:
  BuilderA() : Builder() {}

  virtual Computer *Create() override { return m_computer; }
  virtual void BuildCpu() override {
    m_cpu = new CpuA;
    m_computer->SetCpu(m_cpu);
  }
  virtual void BuildMemory() override {
    m_memory = new MemoryA;
    m_computer->SetMemory(m_memory);
  }
};

class BuilderB : public Builder {
public:
  BuilderB() : Builder() {}
  virtual Computer *Create() override { return m_computer; }
  virtual void BuildCpu() override {
    m_cpu = new CpuB;
    m_computer->SetCpu(m_cpu);
  }
  virtual void BuildMemory() override {
    m_memory = new MemoryB;
    m_computer->SetMemory(m_memory);
  }
};

class Director {
public:
  bool Assemble(Builder *builder) {
    if (builder == nullptr)
      return false;

    builder->BuildCpu();
    builder->BuildMemory();
    return true;
  }
};

void Test() {
  Director direcotr;
  Builder *ptr = new BuilderA;
  direcotr.Assemble(ptr);
  Computer *com = ptr->Create();
  com->Print();
  delete ptr;

  ptr = new BuilderB;
  direcotr.Assemble(ptr);
  com = ptr->Create();
  com->Print();
  delete ptr;
}

int main() {
  Test();
  return 0;
}

执行结果

|-----------------------------------------------------------------------|
| CpuInfo: CpuA, MemoryInfo: MemoryA CpuInfo: CpuB, MemoryInfo: MemoryB |

以上代码示例中，涉及到Memory与Cpu类的多态形式，所以代码中关于这一块的组织实现不太符合相关设计原则，实际生产中应该重新组织代码。整体不影响对建造者模式的阅读理解。

4. 优缺点

将对象的构建过程与表示分离，使得同样的构建过程可以创建不同的表示。
隐藏了构建过程的细节，使得使用者不需要知道对象的具体构建过程。
建造者模式需要定义多个类，增加了系统的复杂性。
建造者模式的使用场景有限，只适用于对象的构建过程比较复杂或需要灵活组合的情况。