建造者模式 c++

建造者模式
定义: 也叫生成器模式,将一个复杂的对象的构建与他的表示分离，使得同样的构建过程可以创建不同的表示。
如果有多个产品类就有几个具体的建造者，而且这多个产品类具有相同的接口或抽象类。
导演类起到封装作用，当建造者模式比较大时，导演类可以有多个。
类图:

Product产品类:
通常实现了模板方法模式，也就是有模板方法和基本方法.
Builder抽象建造者:
规范产品的组建，一般由子类实现。
ConcreteBulider具体建造者:
实现抽象类的定义的所有方法，并返回一个组建好的对象。
Director 指导类:
负责安排已有模块的顺序，然后调用Bulider开始建造。

建造者优点:
1）.客户端不必知道内部实现
2）.建造者独立，容易扩展
3）.具体见到这是独立的，可以对建造过程逐步细化，而不对其他模块产生影响。

使用场景:
1）.相同方法，不同执行顺序，产生不同的事件结果。
2）.多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同
3）.产品类非常复杂，或者产品类的调用顺序不同产生不同的效能
4）.对象使用过程中会使用到系统中的其他对象

建造者模式扩展:
对建造者模式引入模板方法模式

建造者模式与工厂模式:
建造者模式 工厂模式
主要注重调用基本方法的顺序安排，也就是基本方法实现了，也就是零件的装配，顺序不同产生的对象也不同,(顺序不同产生对象不同) 主要重点是创建，创建零件是他的职责，组装顺序不关心

题示:
宝马车奔驰车模型用户随时可能要求更改 指导类只制造了四个模型

代码:

#include <iostream>
#include <vector>
#include <string>
using namespace std;
typedef  vector<string>   ArrayList;
//车辆模型抽象类
class CarModel
{
private:
     ArrayList sequence  =  ArrayList();
protected:
    virtual void start() = 0;
    virtual void stop() = 0;
    virtual void alarm() = 0;
    virtual void engineBoom() = 0;
    public :
    virtual  void run()  final
    {
        for(unsigned int i = 0 ; i <sequence.size(); i++)
        {
            string actionName = sequence[i];
            if(actionName == "start")
                this->start();
            if(actionName == "stop")
                this->stop();
            if(actionName == "alarm")
                this->alarm();
            if(actionName == "engine Boom")
                this->engineBoom();
        }
    }
    public:
    virtual  void setSequence(ArrayList sequence) final
    {
        this->sequence = sequence;
    }
};
//奔驰模型
class BenzModel:public CarModel
{
protected:
    void alarm()
    {
        cout<<"奔驰车的喇叭声是这样的"<<endl;
    }
    void engineBoom()
    {
        cout<<"奔驰车的引擎是这个声音"<<endl;
    }
    void start()
    {
        cout<<"奔驰车跑起来是这个声音"<<endl;
    }
    void stop()
    {
        cout<<"奔驰车应该是这样停车的"<<endl;
    }
};
//宝马模型
class BMWModel:public CarModel
{
protected:
    void alarm()
    {
        cout<<"宝马车的喇叭声是这样的"<<endl;
    }
    void engineBoom()
    {
        cout<<"宝马车的引擎是这个声音"<<endl;
    }
    void start()
    {
        cout<<"宝马车跑起来是这个声音"<<endl;
    }
    void stop()
    {
        cout<<"宝马车应该是这样停车的"<<endl;
    }
};
//抽象汽车组装者
class CarBuilder
{
public:
   virtual void setSequence(ArrayList sequence) = 0;//建造模型 要给组装顺序
   virtual CarModel* getCarModel() = 0 ;//顺序设置完毕，就可以拿到这个车辆模型
};
//奔驰组装者
class BenzBuilder : public CarBuilder
{
private:
    BenzModel benz = BenzModel();
public:
    CarModel* getCarModel()
    {
        return &(this->benz);
    }
    void setSequence(ArrayList sequence)
    {
        this->benz.setSequence(sequence);
    }
};
//宝马组装者
class BMWBuilder : public CarBuilder
{
private:
    BMWModel bmw = BMWModel();
public:
    CarModel* getCarModel()
    {
        return &(this->bmw);
    }
    void setSequence(ArrayList sequence)
    {
        this->bmw.setSequence(sequence);
    }
};
//导演类 只制造了4个模型
class Director
{
private :
    ArrayList sequence  = ArrayList();
    BenzBuilder benzbuilder =  BenzBuilder();
    BMWBuilder  bmwbuilder  =  BMWBuilder();
    /*四个模型*/
public:
    BenzModel getABenzModel()
    {
        /*清理现场*/
        this->sequence.clear();
        this->sequence.push_back("start");
        this->sequence.push_back("stop");
        this->benzbuilder.setSequence(this->sequence);
         CarModel  * car(this->benzbuilder.getCarModel());
         return   *(dynamic_cast<BenzModel*>(car));
    }
    BenzModel getBBenzModel()
    {
        /*清理现场*/
        this->sequence.clear();
        this->sequence.push_back("engine boom");
        this->sequence.push_back("start");
        this->sequence.push_back("stop");
        this->benzbuilder.setSequence(this->sequence);
        CarModel  * car(this->benzbuilder.getCarModel());
        return   *(dynamic_cast<BenzModel*>(car));
    }
     BMWModel getCBMWModel()
    {
        /*清理现场*/
        this->sequence.clear();
        this->sequence.push_back("alarm");
        this->sequence.push_back("start");
        this->sequence.push_back("stop");
        this->bmwbuilder.setSequence(this->sequence);
        CarModel  * car(this->bmwbuilder.getCarModel());
        return   *(dynamic_cast<BMWModel*>(car));
    }
    BMWModel getDBMWModel()
    {
        /*清理现场*/
        this->sequence.clear();
        this->sequence.push_back("alarm");
        this->sequence.push_back("start");
        this->bmwbuilder.setSequence(this->sequence);
        CarModel  * car(this->bmwbuilder.getCarModel());
        return   *(dynamic_cast<BMWModel*>(car));
    }
};
int main()
{
    Director dircetor = Director();
    //2俩A类型奔驰车
 for(int i = 0 ; i < 2 ; i++)
    {
        dircetor.getABenzModel().run();
    }
     for(int i = 0 ; i < 2 ; i++)
    {
        dircetor.getCBMWModel().run();
    }
    return 0;
    return 0;
}
结果：
奔驰车跑起来是这个声音
奔驰车应该是这样停车的
奔驰车跑起来是这个声音
奔驰车应该是这样停车的
宝马车的喇叭声是这样的
宝马车跑起来是这个声音
宝马车应该是这样停车的
宝马车的喇叭声是这样的
宝马车跑起来是这个声音
宝马车应该是这样停车的