设计模式---建造者模式

解释说明：

main()，客户

CCarModel，产品模型

CBenzModel，奔驰模型

CBMWModel，宝马模型

ICarBuilder，建造者接口

CBenzBuilder，奔驰建造者

CBMWBuilder，宝马建造者

CDirector，导演

说明：CCarModel实现模板方法，Builder负责开始建造产品。建造产品时，构建的顺序由Director或main决定。

注意：建造者模式和抽象工厂非常类似。建造者更重视产品建造时的逻辑顺序，而抽象工厂更重视生产出不同型号的产品，抽象工厂不关心顺序。

 

#include <iostream>
#include <vector>

using namespace std;

class CCarModel
{
public:
	CCarModel(){}
	virtual ~CCarModel(){}

	void Run()
	{
		vector<string>::const_iterator it = m_pSequence->begin();
		for (; it < m_pSequence->end(); ++it)
		{
			string actionName = *it;
			if (actionName.compare("start") == 0)
				Start();
			else if (actionName.compare("stop") == 0)
				Stop();
			else if (actionName.compare("alarm") == 0)
				Alarm();
			else if (actionName.compare("engineboom") == 0)
				EngineBoom();
		}
	}
	void SetSequence(vector<string>* pSeq)
	{
		m_pSequence = pSeq;
	}

protected:
	virtual void Start() = 0;
	virtual void Stop() = 0;
	virtual void Alarm() = 0;
	virtual void EngineBoom() = 0;

private:
	vector<string>* m_pSequence;
};

class CBenzModel:public CCarModel
{
public:
	CBenzModel(){}
	~CBenzModel(){}

protected:
	void Start()
	{
		cout << "奔驰发动..." << endl;
	}
	void Stop()
	{
		cout << "奔驰停车..." << endl;
	}
	void Alarm()
	{
		cout << "奔驰鸣笛" << endl;
	}
	void EngineBoom()
	{
		cout << "奔驰引擎声音是这样...." << endl;
	}
};

class CBMWModel :public CCarModel
{
public:
	CBMWModel(){}
	~CBMWModel(){}

protected:
	void Start()
	{
		cout << "宝马发动..." << endl;
	}
	void Stop()
	{
		cout << "宝马停车..." << endl;
	}
	void Alarm()
	{
		cout << "宝马鸣笛" << endl;
	}
	void EngineBoom()
	{
		cout << "宝马引擎声音是这样...." << endl;
	}

};
//建造者基类
class ICarBuilder
{
public:
	ICarBuilder(){}
	virtual ~ICarBuilder(){}

	virtual void SetSequence(vector<string>* pseq) = 0;
	virtual CCarModel* GetCarModel() = 0;
};
//实际建造者1
class CBenzBuilder :public ICarBuilder
{
public:
	CBenzBuilder()
	{//父类指针指向派生类对象指针，可以转换
		m_pBenz = new CBenzModel();
	}
	~CBenzBuilder()
	{
		delete m_pBenz;
	}

	void SetSequence(vector<string>* pSeq)
	{
		m_pBenz->SetSequence(pSeq);
	}
	CCarModel* GetCarModel()
	{
		return m_pBenz;
	}
private:
	CCarModel* m_pBenz;
};

//实际建造者2
class CBMWBuilder :public ICarBuilder
{
public:
	CBMWBuilder()
	{
		m_pBMW = new CBMWModel();
	}
	~CBMWBuilder()
	{
		delete m_pBMW;
	}

	void SetSequence(vector<string>* pSeq)
	{
		m_pBMW->SetSequence(pSeq);
	}
	CCarModel* GetCarModel()
	{
		return m_pBMW;
	}

private:
	CCarModel* m_pBMW;
};

//指导者
class CDirector
{
public:
	CDirector()
	{
		m_pBenzBuilder = new CBenzBuilder();
		m_pBMWBuilder = new CBMWBuilder();
		m_pSeqence = new vector<string>();
	}
	~CDirector()
	{
		delete m_pBenzBuilder;
		delete m_pBMWBuilder;
		delete m_pSeqence;
	}

	CBenzModel* GetABenzModel()
	{
		m_pSeqence->clear();
		m_pSeqence->push_back("start");
		m_pSeqence->push_back("stop");
		m_pBenzBuilder->SetSequence(m_pSeqence);
		return dynamic_cast<CBenzModel*>(m_pBenzBuilder->GetCarModel());
	}
	CBenzModel* GetBBenzModel()
	{
		m_pSeqence->clear();
		m_pSeqence->push_back("engineBoom");
		m_pSeqence->push_back("start");
		m_pSeqence->push_back("stop");
		m_pBenzBuilder->SetSequence(m_pSeqence);
		return dynamic_cast<CBenzModel*>(m_pBenzBuilder->GetCarModel());
	}
	CBMWModel* GetCBMWModel()
	{
		m_pSeqence->clear();
		m_pSeqence->push_back("alarm");
		m_pSeqence->push_back("start");
		m_pSeqence->push_back("stop");
		m_pBMWBuilder->SetSequence(m_pSeqence);
		return static_cast<CBMWModel*>(m_pBMWBuilder->GetCarModel());
		
	}
	CBMWModel* GetDBMWModel()
	{
		m_pSeqence->clear();
		m_pSeqence->push_back("start");
		m_pBenzBuilder->SetSequence(m_pSeqence);
		return dynamic_cast<CBMWModel*>(m_pBMWBuilder->GetCarModel());
	}

private:
	vector<string>* m_pSeqence;
	CBenzBuilder* m_pBenzBuilder;
	CBMWBuilder* m_pBMWBuilder;
};

//没有使用模式时，需要把步骤一条一条的传入模型。
void DoBenzRun()
{
	cout << "----------生成奔驰模型----------" << endl;
	CBenzModel* pBenz = new CBenzModel();
	vector<string> seq;
	seq.push_back("engine boom");
	seq.push_back("start");
	seq.push_back("stop");

	pBenz->SetSequence(&seq);
	pBenz->Run();
	delete pBenz;
}
//使用模式后，由benzBuilder和bmwBuilder来生成，并且使用同样的创建顺序。
void DoBuilder()
{
	cout << "----------用同一个顺序，生成模型----------" << endl;
	vector<string> seq;
	seq.push_back("engineboom");
	seq.push_back("start");
	seq.push_back("stop");

	CBenzBuilder benzBuilder;
	benzBuilder.SetSequence(&seq);
	//基类对象的指针向派生类对象指针转换
	CBenzModel* pBenz = dynamic_cast<CBenzModel*>(benzBuilder.GetCarModel());
	pBenz->Run();
}

void DoDirection()
{//使用指导者来封装创建的逻辑，把创建的顺序内聚在指导者类里面。
	cout << "----------批量生成模型----------" << endl;
	CDirector director;

	//1W辆A类型的奔驰车/
	for (int i = 0; i < 2; i++)
		director.GetABenzModel()->Run();
	//100W辆B类型的奔驰车
	for (int i = 0; i < 2; i++)
		director.GetBBenzModel()->Run();
	// 1000W辆C类型的宝马车
	for (int i = 0; i < 2; i++)
		director.GetCBMWModel()->Run();
}

int main()
{
	//DoBenzRun();
	
	//DoBuilder();

	DoDirection();

	return 0;
}