C++设计模式——建造者模式(Builder Pattern)

C++设计模式——建造者模式(Builder Pattern)

微信公众号：幼儿园的学霸

目录

定义

The intent of the Builder design pattern is to separate the construction of a complex object from its representation. By doing so the same construction process can create different representations.
将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示

建造者模式属于创建型设计模式，它主要是将一个复杂对象的构建与表示分离，使用多个简单的对象一步一步构建成一个复杂的对象，它提供了一种创建对象的最佳方式。对于相同的建造过程，不同的建造者会得到不同的建造结果。

建造者（Builder）模式的主要角色如下:

• 产品角色（Product）：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个部件。
• 抽象建造者（Builder）：它是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的方法 getResult()。
• 具体建造者(Concrete Builder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。
• 指挥者（Director）：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，指挥者（Director）直接和客户（Client）进行需求沟通。在指挥者中不涉及具体产品的信息。

建造者模式类图如下：

代码示例

#include <bits/stdc++.h>


//
//建造者模式
//关键：建造者类：创建和提供实例
//     Director类:管理建造出来的实例的依赖关系

//具体的产品类Product
class Order {
private:
    std::string m_strFood;
    std::string m_strDrink;
public:
    //set 方法
    void setFood(const std::string &food) {
        m_strFood = food;
    }

    void setDrink(const std::string &drink) {
        m_strDrink = drink;
    }

    //get 方法
    const std::string &food() {
        std::cout << m_strFood << std::endl;
        return m_strFood;
    }

    const std::string &drink() {
        std::cout << m_strDrink << std::endl;
        return m_strDrink;
    }
};

//抽象建造者类.提供建造接口 Builder
class OrderBuilder {
public:
    virtual ~OrderBuilder() = default;//基类析构函数建议定义为虚析构函数
    virtual void setOrderFood() = 0;

    virtual void setOrderDrink() = 0;

    virtual std::shared_ptr<Order> getOrder() = 0;
};

//具体的建造者类 Concrete Builder
class VegetarianOrderBuilder : public OrderBuilder {
private:
    std::shared_ptr<Order> m_pOrder;
public:
    VegetarianOrderBuilder() {
        m_pOrder = std::make_shared<Order>();
    }

    ~VegetarianOrderBuilder() {
        std::cout << "In ~VegetarianOrderBuilder !" << std::endl;
    }

public:
    std::shared_ptr<Order> getOrder() override {
        return m_pOrder;
    }

    void setOrderFood() override {
        m_pOrder->setFood("vegetable order ! ");
    }

    void setOrderDrink() override {
        m_pOrder->setDrink("water order !");
    }
};

//具体的建造者类
class MeatOrderBuilder : public OrderBuilder {
private:
    std::shared_ptr<Order> m_pOrder;
public:
    MeatOrderBuilder() {
        m_pOrder = std::make_shared<Order>();
    }

    ~MeatOrderBuilder() {
        std::cout << "In ~MeatOrderBuilder !" << std::endl;
    }

public:
    std::shared_ptr<Order> getOrder() override {
        return m_pOrder;
    }

    void setOrderFood() override {
        m_pOrder->setFood("beef order ! ");
    }

    void setOrderDrink() override {
        m_pOrder->setDrink("beer order !");
    }
};

//Director类，负责管理实例创建的依赖关系，指挥构建者类创建实例
class Director {
private:
    std::shared_ptr<OrderBuilder> m_pOrderBuilder;
public:
    Director(std::shared_ptr<OrderBuilder> _pOrderBuilder)
            : m_pOrderBuilder(_pOrderBuilder) {

    }

    void construct() {
        m_pOrderBuilder->setOrderFood();
        m_pOrderBuilder->setOrderDrink();
    }
};


int main() {
    std::shared_ptr<Order> pOrder = nullptr;
    std::shared_ptr<Director> pDirector = nullptr;
    std::shared_ptr<OrderBuilder> pOrderBuilder = nullptr;

    //区分作用域，查看析构函数调用情况
    {
        pOrderBuilder = std::make_shared<MeatOrderBuilder>();
        pDirector = std::make_shared<Director>(pOrderBuilder);
        pDirector->construct();
        pOrder = pOrderBuilder->getOrder();
        pOrder->food();
        pOrder->drink();
    }

    {
        pOrderBuilder = std::make_shared<VegetarianOrderBuilder>();
        pDirector = std::make_shared<Director>(pOrderBuilder);
        pDirector->construct();
        pOrder = pOrderBuilder->getOrder();
        pOrder->food();
        pOrder->drink();
    }

    return 0;

    //运行结果如下：
    //beef order !
    //beer order !
    //In ~MeatOrderBuilder !
    //vegetable order !
    //water order !
    //In ~VegetarianOrderBuilder !
}

总结

建造者模式与抽象工厂模式的比较

建造模式和工厂模式极为相似，都是将对象的构建过程和对象的业务处理分离开来，让不同的类型分别承担对象的创建和对象的使用的责任。

建造者（Builder）模式和工厂模式的关注点不同：建造者模式注重零部件的组装过程，而工厂方法模式更注重零部件的创建过程，但两者可以结合使用。

与抽象工厂模式相比，建造者模式返回一个组装好的完整产品，而抽象工厂模式返回一系列相关的产品，这些产品位于不同的产品等级结构，构成了一个产品族 。

在抽象工厂模式中，客户端实例化工厂类，然后调用工厂方法获取所需产品对象，而在建造者模式中，客户端可以不直接调用建造者的相关方法，而是通过指挥者类来指导如何生成对象，包括对象的组装过程和建造步骤，它侧重于一步步构造一个复杂对象，返回一个完整的对象 。

如果将抽象工厂模式看成汽车配件生产工厂，生产一个产品族的产品，那么建造者模式就是一个汽车组装工厂，通过对部件的组装可以返回一辆完整的汽车

优缺点

• 优点
  1.各个具体的建造者类之间相互独立，有利于系统的扩展。
  2.客户端不必知道产品内部组成的细节，便于控制细节风险。

• 缺点
  1.建造者模式所创建的产品一般具有较多的共同点，其组成部分相似；如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。
  2.如果产品的内部变化复杂，该模式会增加很多的建造者类，导致系统变得很庞大。

建造者模式将复杂产品的构建过程封装在不同的方法中，使得创建过程非常清晰，能够让我们更加精确的控制复杂产品对象的创建过程，同时它隔离了复杂产品对象的创建和使用，使得相同的创建过程能够创建不同的产品。

适用场景

1.隔离复杂对象的创建和使用，相同的方法，不同执行顺序，产生不同事件结果
2.多个部件都可以装配到一个对象中，但产生的运行结果不相同
3.产品类非常复杂或者产品类因为调用顺序不同而产生不同作用
4.初始化一个对象时，参数过多，或者很多参数具有默认值
5.Builder模式不适合创建差异性很大的产品类
6.产品内部变化复杂，会导致需要定义很多具体建造者类实现变化，增加项目中类的数量，增加系统的理解难度和运行成本
7.需要生成的产品对象有复杂的内部结构，这些产品对象具备共性；

参考资料

1.一篇文章就彻底弄懂建造者模式(Builder Pattern)
2.设计者模式详解–建造者模式
3.C++ 常用设计模式（学习笔记）

---

下面的是我的公众号二维码图片，欢迎关注。