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

最新推荐文章于 2020-11-29 22:09:16 发布

原创最新推荐文章于 2020-11-29 22:09:16 发布 · 432 阅读

3 ·

CC 4.0 BY-SA版权

C/C++设计模式同时被 2 个专栏收录

32 篇文章

订阅专栏

设计模式

30 篇文章

订阅专栏

建造者模式

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

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

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

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

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

适用情况：

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

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

在这里插入图片描述

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

Factory模式中：

有一个抽象的工厂
实现一个具体的工厂 - 汽车工厂
工厂生产的汽车A，得到汽车产品A
工厂生产汽车B，得到汽车产品B

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

Builder模式

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

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

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

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

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;
}