设计模式观后（c++还原之八 建造者模式）

//从前面的知识知道，重复功能函数放基类（视情况）run
//车辆模型抽象基类
class CarModel {
private:
    deque<string>* m_psequence;
    
protected:
    virtual void Start() = 0;
    virtual void Stop() = 0;
    virtual void Alarm() = 0;
    virtual void EngineBoom() = 0;
    
public:
    void run() {
        for (int i = 0; i < m_psequence->size(); i++) {
            string actionName = m_psequence->at(i);
            if (!actionName.compare("start")) {
                Start();
            } else if (!actionName.compare("stop")) {
                Stop();
            } else if (!actionName.compare("alarm")) {
                Alarm();
            } else if (!actionName.compare("engine boom")) {
                EngineBoom();
            }
        }
    }
    
    void SetSequence(deque<string>* sequence) {
        *m_psequence = *sequence;
    }
};

//派生奔驰模型类，和宝马模型类。重写虚函数OK!。（）
class BenzModel : public CarModel {
public:
    BenzModel();
};
class BMWModel : public CarModel {
public:
    BMWModel();
};

//添加功能，现在来抽象功能基类组装者
class CarBuilder {
public:
    virtual void SetSequence(std::deque<string> sequence) {};
    virtual CarModel* GetCarModel() = 0;
    
};
class BenzBuilder : public CarBuilder {
private:
    BenzModel* pbenz;
public:
    CarModel* GetCarModel() {
        return pbenz;
    }
    void SetSequence(deque<string>* sequence) {
        pbenz->SetSequence(sequence);
    }
};
class BMWBuilder : public CarBuilder {
private:
    BMWModel* pbmw;
public:
    CarModel* GetCarMode() {
        return pbmw;
    }
    void SetSequence(deque<string>* sequence) {
        pbmw->SetSequence(sequence);
    }
};

class Client {
    static void main() {
        //调用奔驰类
        deque<string>* sequece = new deque<string>();
        sequece->push_back("engine boom");
        sequece->push_back("start");
        
        BenzBuilder* pbenz = new BenzBuilder();
        pbenz->SetSequence(sequece);
        
        BenzModel* benz = (BenzModel*)pbenz->GetCarModel();
        benz->run();
    }
};
//先是产品类，像前面说的那样；构建产品抽象基类和产品实体派生类
//然后是建造者，（同上面的操作） 对实体类进行封装，返回组建好了的对象。
//最后的场景类，一望作者风格。