23种设计模式C++源码与UML实现--建造者模式

建造者模式

代码仓库地址:建造者模式

Builder模式也叫建造者模式或者生成器模式,是由GoF提出的23种设计模式中的一种。Builder模式是一种对象创建模式之一,用来隐藏复合对象的创建过程。他把复合对象的创建过程加以抽象,通过子类继承和重载的方式,动态地创建具有复合属性的对象。

对象的创建:Builder模式是为了对象的创建而设计的模式-创建的是一个复合对象,被创建的对象为一个具有复合属性的复合对象,关注对象创建的各个部分的创建过程,不同工厂(Builder)对产品属性有不同的创建方法。

  • Builder:为创建产品各个部分,统一抽象接口
  • ConcreteBuilder: 具体的创建产品的各个部分,部分A,部分B,部分C
  • Director: 构造一个使用Builder接口的对象
  • Product:表示被构造的复杂对象

ConcreteBuilder创建该产品的内部表示并定义它的装配过程,包含定义组成部分的类,包含将这些部件装配成最终产品的接口。

适用情况:

​ 一个对象的构建比较复杂,将一个对象的构建和对象的表示进行分离。

说白了:建造者模式,其实就是相当于一个设计师,指挥建造师造房子,建造师可能是不同的,因为每个建造师建造水平和会造的房子都是不一样的。

在这里插入图片描述

创建者模式和工厂模式的对比

Factory模式中:

  1. 有一个抽象的工厂
  2. 实现一个具体的工厂 - 汽车工厂
  3. 工厂生产的汽车A,得到汽车产品A
  4. 工厂生产汽车B,得到汽车产品B

实现了购买者和生产线的隔离,强调的是结果

Builder模式

  1. 引擎工厂生产引擎产品,得到汽车的部件A
  2. 轮胎工厂生产轮子产品,得到汽车部件B
  3. 底盘工厂生产车身产品,得到汽车部件C
  4. 将这些部件放到一起,形成刚好能够组装成一辆汽车的整体

这样做,目的是为了实现复杂对象生产线和其部件的解耦。强调的是过程

两者的区别在于以下几种情况:

工厂模式不考虑对象的组装过程,而直接生成一个我想要的对象。

Builder模式先一个个的创建对象的每一个部件,再统一组装成一个对象

工厂模式所解决的问题是,工厂生产产品

Builder模式解决的是工厂控制产品 生成器组装各个部件的过程,然后从产品生成器中得到产品。

前期问题的抛出-需要建造者模式的原因

#include <iostream>
#include <string>
using namespace std;


class House
{
public:
    void setDoor(string door)
    {
        this->m_door = door;
    }
    void setWall(string wall)
    {
        this->m_wall = wall;
    }
    void setWindow(string window)
    {
        this->m_window = window;
    }
    string getDoor(void)
    {
        cout << m_door << endl;
        return m_door;
    }
    string getWall(void)
    {
        cout << m_wall << endl;
        return m_wall;
    }
    string getWindow(void)
    {
        cout << m_window << endl;;
        return m_window;
    }

private:
    string m_door;
    string m_wall;
    string m_window;
};

class Builder
{
public:
    Builder(void)
    {
        m_house = new House;
    }
    ~Builder(void)
    {
        delete m_house;
    }
    void MakeBuilder(void)
    {
        BuildDoor(m_house);
        BuildWall(m_house);
        BuildWindow(m_house);
    }
    void BuildDoor(House *h)
    {
        h->setDoor("door");
    }
    void BuildWall(House *h)
    {
        h->setWall("wall");
    }
    void BuildWindow(House *h)
    {
        h->setWindow("window");
    }
    House *GetHouse(void)
    {
        return m_house;
    }

private:
    House *m_house;
};

int main(int argc, char const *argv[])
{
    
    // 不需要建造者,客户直接造房子
    //  门窗  墙体玻璃等都需要用户管理
    House *house = new House;
    house->setDoor("user door");
    house->setWall("user Wall");
    house->setWindow("big window");
    house->getDoor();
    house->getWall();
    house->getWindow();
    delete house;

    // 华丽的分割线
    cout << "=========================" << endl;
    // 请工程队 建造房子
    // 将建造过程交给工程队, 是不是还可以请个指挥建造的? 这样客户就能完全解放出来了
    Builder *builder = new Builder;
    builder->MakeBuilder();
    house = builder->GetHouse();
    house->getDoor();
    house->getWall();
    house->getWindow();
    delete builder;

    cout << "builder pattern." << endl;
    return 0;
}

两者,虽然都建造好了房子,但是建筑队参加之后,客户就不需要参与房子的建造的每个过程了,将建造过程与使用者之间进行分离,这就是建造者模式想要达到的效果

andrew@andrew-G3-3590:/work/linux-sys/DesignPatterns/cpp/build$ ./builder_pattern_question 
user door
use Wall
big window
=========================
door
wall
window
builder pattern.

那除了这样其实可以再请一个指挥者过来,因为实际中会有不同的建造者参与竞争,每个建造者精通的地方都是不一样的,指挥者参与之后,用户只需要把自己的需求告知指挥者就行。

  • 建造者模式,就是通过虚工程对基类,实现通过指挥者,指挥不同的建筑队建设不同的房子
#include <iostream>
#include <string>
using namespace std;

// 建造者模式,就是通过虚工程对基类,实现
// 通过指挥者,指挥不同的建筑队建设不同的房子

class House
{
public:
    void setDoor(string door)
    {
        this->m_door = door;
    }
    void setWall(string wall)
    {
        this->m_wall = wall;
    }
    void setWindow(string window)
    {
        this->m_window = window;
    }

    string getDoor(void)
    {
        cout << m_door << endl;
        return m_door;
    }

    string getWall(void)
    {
        cout << m_wall << endl;
        return m_wall;
    }

    string getWindow(void)
    {
        cout << m_window << endl;;
        return m_window;
    }

private:
    string m_door;
    string m_wall;
    string m_window;
};

class Builder
{
public:
    virtual void BuildWall(void) = 0;
    virtual void BuildDoor(void) = 0;
    virtual void BuildWindow(void) = 0;
    virtual House* GetHouse(void) = 0;
public:
    virtual ~Builder(void)
    {

    }
};

//公寓建筑工程队
class FlatBuilder : public Builder
{
public:
    FlatBuilder()
    {
        m_house = new House;
    }

    virtual void BuildWall(void)
    {
        m_house->setWall("flat wall");
    }

    virtual void BuildDoor(void)
    {
        m_house->setDoor("flat door");
    }

    virtual void BuildWindow(void)
    {
        m_house->setWindow("flat window");
    }

    virtual House* GetHouse(void)
    {
        return m_house;
    }

private:
    House *m_house;
};

// 别墅工程队
class VillaBuilder : public Builder
{
public:
    VillaBuilder(void)
    {
        m_house = new House;
    }

    virtual void BuildWall(void)
    {
        m_house->setWall("villa wall");
    }

    virtual void BuildDoor(void)
    {
        m_house->setDoor("villa door");
    }

    virtual void BuildWindow(void)
    {
        m_house->setWindow("villa window");
    }

    virtual House* GetHouse(void)
    {
        return m_house;
    }
    
private:
    House *m_house;
};

// 设计师 指挥者,负责建造的逻辑
// 建筑队,干具体的活
class Director
{
public:
    Director(Builder *builder)
    {
        m_build = builder;
    }

    void Construct(void)
    {
        m_build->BuildWall();
        m_build->BuildWindow();
        m_build->BuildDoor();
    }

private:
    Builder * m_build;
};

int main(int argc, char const *argv[])
{
    House       *house = NULL;
    Builder     *builder = NULL;
    Director    *director = NULL;
    cout << "villa build" << endl;
    // 请一个建造别墅的工程队,建造一个别墅
    builder = new VillaBuilder;

    // 设计师 指挥工程队进行建造
    director = new Director(builder);
    // 指挥干活
    director->Construct();
    // 建好 交工
    house = builder->GetHouse();
    // 客户验房
    house->getWindow();
    house->getDoor();
    house->getWall();
    delete house;
    delete builder;

    cout << "flat build" << endl;
    builder = new FlatBuilder;
    director = new Director(builder);
    director->Construct();
    house = builder->GetHouse();
    house->getDoor();
    house->getWall();
    house->getWindow();
    delete house;
    delete builder;

    delete director;
    cout << "builder pattern." << endl;
    return 0;
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Achilles.Wang

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值