创建型 建造者模式

简介: 创建型 建造者模式

建造者模式(Builder Pattern): 多个简单的对象一步一步构建成一个复杂的对象。

如:肯德基,汉堡、可乐、薯条、炸鸡翅等是不变的,而其组合是经常变化的,生成出所谓的“套餐”;

建造者模式

提供一种封装,管理各个子对象的创建。

逻辑分析:

目标是同一个产品,可以由不同模块组装而成。

==》所以需要定义一个产品类,以及组装模块提供函数。

不同的模块需要不同的组装构造,就是我们的构建者。(控制产品类不同的构造)

==》需要提供基础类,操作一个产品对象,提供方法对其中的产品对象做不同的模块控制

==》需要提供产品的生成接口。

==》通过子类实现不同模块的不同创建

使用场景:

如盖房子,门的设计,走廊的设计,室内的设计等,分别可以做不同的封装然后组合进行构造。

源码Demo:

#include <string.h>
#include <iostream>
using namespace std;
//造房子 可以模块化构造然后组装 这里我们定义房子的基本属性  ==》目标建筑
class House
{
public:
  void setFloor(string floor){
    this->m_floor = floor;
  }
  void setWall(string wall){
    this->m_wall = wall;
  }
  void setDoor(string door){
    this->m_door = door;
  }
  string getFloor(){
    return m_floor;
  }
  string getWall(){
    return  m_wall; 
  }
  string getDoor(){
    return m_door;
  }
private:
  string   m_floor;
  string   m_wall;
  string   m_door;
};
//用构建者模型来进行管理 不同的模型可以用继承的方式管理
//构造一个产品对象,并设定不同的模块构造接口
class Builder
{
public:
  virtual void makeFloor() = 0;
  virtual void makeWall() = 0;
  virtual void makeDoor() = 0;
  virtual House *GetHouse() = 0;
  virtual ~Builder() {}
};
//不同的子类 实现不同的产品模块定制  ==》建筑师
class VillaBuild : public Builder//别墅
{
public:
  VillaBuild(){
    pHouse = new House;
  }
  ~VillaBuild()
  {
    if(pHouse != nullptr)
    {
      delete pHouse;
      pHouse = nullptr;
    }
  }
  virtual void makeFloor(){
    pHouse->setFloor("villa floor");
  }
  virtual void makeWall(){
    pHouse->setWall("villa Wall");
  }
  virtual void makeDoor(){
    pHouse->setDoor("villa Door");
  }
  virtual House *GetHouse(){
    return pHouse; 
  }
private:
  House *pHouse;
};
class FlatBuild : public Builder//公寓
{
public:
  FlatBuild(){
    pHouse = new House; 
  }
  ~FlatBuild()
  {
    if(pHouse != nullptr)
    {
      delete pHouse;
      pHouse = nullptr;
    }
  }
  virtual void makeFloor(){
    pHouse->setFloor("flat Door");
  }
  virtual void makeWall(){
    pHouse->setWall("flat Wall");
  }
  virtual void makeDoor(){
    pHouse->setDoor("flat Door");
  }
  virtual House *GetHouse(){
    return pHouse;
  }
private:
  House *pHouse;
};
//如果子类过多,产品模型过多,可以用同一个接口对其进行管理  ==》设计者
//通过具体的子类对象  构建不同的建筑类型
class Director
{
public://这里使用的对象注入的功能,将你建造的对象,通过指针传递过来,然后使用指针进行操作
  void Construct(Builder *builder)
  {
    builder->makeFloor();
    builder->makeWall();
    builder->makeDoor();
  }
};
int main()
{
  //设计师提供建筑模板类 可以自己定制不用这个类
  Director * director = new Director();
  //根据需要定制要创建的目标建筑 建筑师创建
  Builder * builder = new VillaBuild();
  //直接通过建筑模板(类似工厂方法进行创建)
  director->Construct(builder);
  //获取建造结果 进行查看
  House * house = builder->GetHouse();
  cout<<"VillaBuild floor:"<<house->getFloor()<<endl;
  cout<<"VillaBuild wall:"<<house->getWall()<<endl;
  cout<<"VillaBuild door:"<<house->getDoor()<<endl;
  if(builder != nullptr)
  {
    delete builder;
    builder = nullptr;
  }
  //创建另一种类型的建筑
  builder = new FlatBuild();
  //通过模板进行构建 ==》设计师
  director->Construct(builder);
  house = builder->GetHouse();
  cout<<"FlatBuild floor:"<<house->getFloor()<<endl;
  cout<<"FlatBuild wall:"<<house->getWall()<<endl;
  cout<<"FlatBuild door:"<<house->getDoor()<<endl;
  if(builder != nullptr)
  {
    delete builder;
    builder = nullptr;
  }
  if(director != nullptr)
  {
    delete director;
    director = nullptr;
  }
  return 0;
}
目录
相关文章
|
4月前
创建型 抽象工厂模式
创建型 抽象工厂模式
23 1
|
3月前
|
设计模式 NoSQL 中间件
设计模式 - 创建型模式_抽象工厂模式
设计模式 - 创建型模式_抽象工厂模式
23 0
|
6月前
|
设计模式 算法
创建型设计模式04-建造者模式
创建型设计模式04-建造者模式
16 0
|
8月前
|
设计模式
设计模式-创建型模式:建造者
设计模式-创建型模式:建造者
|
11月前
|
算法
创建型模式-建造者模式
创建型模式-建造者模式
43 0
|
设计模式 测试技术 数据库
设计模式 - 创建型模式_建造者模式
建造者模式所完成的内容就是通过将多个简单对象通过⼀步步的组装构建出⼀个复杂对象的过程。
58 0
设计模式 - 创建型模式_建造者模式
|
XML 设计模式 JSON
创建型:抽象工厂模式
创建型:抽象工厂模式
83 0
|
设计模式 Java
【设计模式】-创建型模式-第2章第3讲-【建造者模式】
【设计模式】-创建型模式-第2章第3讲-【建造者模式】
【设计模式】-创建型模式-第2章第3讲-【建造者模式】
|
存储 缓存 JavaScript
05.创建型:工厂方法模式
创建型:工厂方法模式
66 0
|
设计模式 算法 C++