设计模式（5）建造者模式

最新推荐文章于 2024-08-27 17:19:33 发布

碎步の流年

最新推荐文章于 2024-08-27 17:19:33 发布

阅读量92

点赞数

分类专栏：设计模式

本文链接：https://blog.csdn.net/qq_24649627/article/details/115176069

版权

设计模式专栏收录该内容

25 篇文章 3 订阅

订阅专栏

建造者模式

建造者模式将客户端与包含多个部件的复杂对象的创建进行了分离，客户端不必知道复杂对象的内部组成与方式，只需要知道所需建造者就行了。
换个通俗的方式来说，盖房子的时候开发商将希望盖得房子的设计图给了施工方，施工方按照自己公司设计的施工流程去打地基，盖房子，进行内部装修等，开发商只需要联系好有资质的施工方就行了，其他的交给施工方去施工，施工方会按照开发商的设计图，去建造出不同的风格的房子。

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

建造者模式结构

建造者模式的结构包含以下几个角色：

抽象建造者（AbstractBuilder）：创建一个Product对象的各个部件指定的抽象接口；
具体建造者（ConcreteBuilder）：实现AbstractBuilder的接口，实现各个部件的具体构造方法和装配方法，并返回创建结果。
产品（Product）：具体的产品对象
指挥者（Director）：构建一个使用Builder接口的对象，安排复杂对象的构建过程，客户端一般只需要与Director交互，指定建造者类型，然后通过构造函数或者setter方法将具体建造者对象传入Director。它主要作用是：隔离客户与对象的生产过程，并负责控制产品对象的生产过程。

UML示意图：
在这里插入图片描述
现在看一下UML图，Director根据需求选择合适的Builder，然后Builder会建造其对应的Product。Director不必知道Builder具体如何去实现Product的生产过程。

建造者模式代码实例

BuilderPattern.h

#include <iostream>
#include <string.h>

using namespace std;

//产品类House
class House
{
public:
  House() {}

  void setFloor(string iFloor)
  {
    this->floor = iFloor;
  }

  void setWall(string iWall)
  {
    this->wall = iWall;
  }

  void setRoof(string iRoof)
  {
    this->roof = iRoof;
  }

  //打印House信息
  void printfHouseInfo()
  {
    cout << "Floor " << this->floor.c_str() << "\n";
    cout << "Wall " << this->wall.c_str() << "\n";
    cout << "Roof " << this->roof.c_str() << "\n\n";
  }

private:
  string floor;
  string wall;
  string roof;
};

//抽象建造者AbstractBuilder
class AbstractBuilder
{
public:
  AbstractBuilder()
  {
    house = new House();
  }

  virtual ~AbstractBuilder()
  {
    if (house != nullptr)
    {
      house = nullptr;
      delete house;
    }
  }

  //抽象方法：
  virtual void buildFloor() = 0;
  virtual void buildWall() = 0;
  virtual void buildRoof() = 0;
  virtual House *getHouse() = 0;

  House *house;
};

//具体建造者ConcreteBuilderA
class ConcreteBuilderA : public AbstractBuilder
{
public:
  ConcreteBuilderA()
  {
    printf("ConcreteBuilderA\n");
  }

  ~ConcreteBuilderA()
  {
    if (this->house != nullptr)
    {
      house = nullptr;
      delete house;
    }
  }

  //具体实现方法
  void buildFloor()
  {
    this->house->setFloor("Floor_A");
  }

  void buildWall()
  {
    this->house->setWall("Wall_A");
  }

  void buildRoof()
  {
    this->house->setRoof("Roof_A");
  }

  House *getHouse()
  {
    return this->house;
  }
};

//具体建造者ConcreteBuilderB
class ConcreteBuilderB : public AbstractBuilder
{
public:
  ConcreteBuilderB()
  {
    printf("ConcreteBuilderB\n");
  }

  ~ConcreteBuilderB()
  {
    if (this->house != nullptr)
    {
      house = nullptr;
      delete house;
    }
  }

  //具体实现方法
  void buildFloor()
  {
    this->house->setFloor("Floor_B");
  }

  void buildWall()
  {
    this->house->setWall("Wall_B");
  }

  void buildRoof()
  {
    this->house->setRoof("Roof_B");
  }

  House *getHouse()
  {
    return this->house;
  }
};

//指挥者Director
class Director
{
public:
  Director() : builder(nullptr) {}

  ~Director()
  {
    if (this->builder != nullptr)
    {
      builder = nullptr;
      delete builder;
    }
  }
  //具体实现方法
  void setBuilder(AbstractBuilder *iBuilder)
  {
    this->builder = iBuilder;
  }

  House *construct()
  {
    builder->buildFloor();
    builder->buildWall();
    builder->buildRoof();
    return builder->getHouse();
  }

private:
  AbstractBuilder *builder;
};

BuilderPattern.cpp

#include "BuilderPattern.h"

int main()
{
  // 抽象建造者 builder
	AbstractBuilder *builder;
  // 装饰者
	Director *director = new Director();
  // 产品类：house
	House *house;

  // 新建具体建造者A
	builder = new ConcreteBuilderA();
	director->setBuilder(builder);
	house = director->construct();
	house->printfHouseInfo();
	delete builder;

  // 新建具体建造者B
	builder = new ConcreteBuilderB();
	director->setBuilder(builder);
	house = director->construct();
	house->printfHouseInfo();

	director->~Director();
	builder->~AbstractBuilder();

	return 0;
}

建造者模式总结

从客户端可以看出，客户根据需要指定对应的建造者，并将建造者作为参数传递给指挥者，通过指挥者既可以得到结果。客户端无需关心产品的具体建造过程。
如果要更换建造风格，只需更换具体建造者即可，不同建造者之间并无任何关联，方便替换。从代码优化角度来看，其实可以不需要指挥者Director的角色，而直接把construct方法放入具体建造者当中。

优点：