3、创建型模式——建造者模式

动机

无论是在现实世界中还是在软件系统中，都存在一些复杂的对象，它们拥有多个组成部分，如汽车，它包括车轮、方向盘、发送机等各种部件。

• 而对于大多数用户而言，无须知道这些部件的装配细节，也几乎不会使用单独某个部件，而是使用一辆完整的汽车，可以通过建造者模式对其进行设计与描述。

• 建造者模式可以将部件和其组装过程分开，一步一步创建一个复杂的对象。用户只需要指定复杂对象的类型就可以得到该对象，而无须知道其内部的具体构造细节。

在软件开发中，也存在大量类似汽车一样的复杂对象，它们拥有一系列成员属性：

• 这些成员属性中有些是引用类型的成员对象。
• 而且在这些复杂对象中，还可能存在一些限制条件，
  • 如某些属性没有赋值则复杂对象不能作为一个完整的产品使用；
  • 有些属性的赋值必须按照某个顺序，一个属性没有赋值之前，另一个属性可能无法赋值等。

复杂对象相当于一辆有待建造的汽车，而对象的属性相当于汽车的部件，建造产品的过程就相当于组合部件的过程。

• 由于组合部件的过程很复杂，因此，这些部件的组合过程往往被“外部化”到一个称作建造者的对象里；
• 建造者返还给客户端的是一个已经建造完毕的完整产品对象，而用户无须关心该对象所包含的属性以及它们的组装方式，这就是建造者模式的模式动机。

定义

Builder Pattern：建造者模式是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。

类图

生成器（Builder）：接口声明在所有类型生成器中通用的产品构造步骤。

具体生成器（Concrete Builders）：提供构造过程的不同实现。具体生成器也可以构造不遵循通用接口的产品。

产品（Products）：最终生成的对象。由不同生成器构造的产品无需属于同一类层次结构或接口。

主管（Director）：定义调用构造步骤的顺序，这样你就可以创建和复用特定的产品配置。

客户端（Client）：必须将某个生成器对象与主管类关联。一般情况下，你只需通过主管类构造函数的参数进行一次性关联即可。此后主管类就能使用生成器对象完成后续所有的构造任务。

时序图

代码

Product.h：

#ifndef PRODUCT_H_
#define PRODUCT_H_

class Car
{
public:
    Car(){}

    void set_car_tire(std::string t)
    {
        tire_ = t;
        std::cout<<"set tire:"<<tire_<<std::endl;
    }

    void set_car_steering_wheel(std::string sw)
 	{
        steering_wheel_ = sw;
        std::cout<<"set steering wheel :"<<steering_wheel_<<std::endl;
    }

    void set_car_engine(std::string e)
    {
        engine_ = e;
        std::cout<<"set engine :"<<engine_<<std::endl;
    }
private:
	std::string tire_;                   //轮胎
    std::string steering_wheel_;         //方向盘
    std::string engine_;                 //发动机
};

Builder.h：

#ifndef BUILDER_H_
#define BUILDER_H_
#include"Product.h"


class CarBuilder
{
public:
    Car getCar(){return car_;}

    //抽象方法
    virtual void buildTire() = 0;
    virtual void buildSteeringWheel() = 0;
    virtual void buildEngine() = 0;
protected:
    Car car_;
};

#endif //BUILDER_H_

ConcreteBuilder.h：

#ifndef CONCRETE_BUILDER_H_
#define CONCRETE_BUILDER_H_

#include"Builder.h"

//具体建造者 奔驰
class BenzBuilder:public CarBuilder
{
public:
    //具体实现方法
    void buildTire() override
    {
        car_.set_car_tire("benz_tire");
    }
    void buildSteeringWheel() override
    {
        car_.set_car_steering_wheel("benz_steering_wheel");
    }

    void buildEngine() override
    {
        car_.set_car_engine("benz_engine");
    }
};

//具体建造者 奥迪
class AudiBuilder:public CarBuilder
{
public:
    //具体实现方法
    void buildTire() override
    {
        car_.set_car_tire("Audi_tire");
    }

    void buildSteeringWheel() override
    {
        car_.set_car_steering_wheel("Audi_steering_wheel");
    }

    void buildEngine() override
    {
        car_.set_car_engine("Audi_engine");
    }
};

#endif //CONCRETE_BUILDER_H_

Director.h：

#ifndef DIRECTOR_H_
#define DIRECTOR_H_
#include"Builder.h"

class Director
{
public:
    Director():builder_(nullptr){}

    void set_builder(CarBuilder* cb)
    {
        builder_ = cb;
    }

    //组装汽车
    Car ConstructCar()
    {
        builder_->buildTire();
        builder_->buildSteeringWheel();
        builder_->buildEngine();
        return builder_->getCar();
    }
private:
    CarBuilder* builder_;
};

#endif //DIRECTOR_H_
    

main.cpp：

#include<iostream>
#include"Director.h"
#include"ConcreteBuilder.h"

int main()
{
    //抽象建造者（一般是动态确定的）
    CarBuilder* builder;
    //指挥者
    Director* director = new Director();

    //产品
    Car car;
    
    //建造奔驰
    std::cout << "==========construct benz car==========" << std::endl;
    builder = new BenzBuilder();
    director->set_builder(builder);
    car = director->ConstructCar();
    delete builder;


    //建造奥迪
    std::cout << "==========construct audi car==========" << std::endl;
    builder = new AudiBuilder();
    director->set_builder(builder);
    car = director->ConstructCar();
    delete builder;
    
    std::cout << "==========done==========" << std::endl;
    delete director;

    return 0;
}