设计模式C++学习笔记之十（Builder建造者模式）
2012-01-16 16:52
495 查看
建造者模式，将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。一段晦涩难懂的文字，实现创建不同表示的方法就是给创建的过程传入创建的参数。详细的还是看代码吧。
10.1.解释
main()，客户CCarModel，产品模型
CBenzModel，奔驰模型
CBMWModel，宝马模型
ICarBuilder，建造者接口
CBenzBuilder，奔驰建造者
CBMWBuilder，宝马建造者
CDirector，导演
说明：CCarModel实现模板方法，Builder负责开始建造产品。建造产品时，构建的顺序由Director或main决定。
注意：建造者模式和抽象工厂非常类似。建造者更重视产品建造时的逻辑顺序，而抽象工厂更重视生产出不同型号的产品，抽象工厂不关心顺序。
看代码：
// Builder.cpp
#include "stdafx.h"
#include "CarModel.h"
#include "BenzModel.h"
#include "BMWModel.h"
#include "BenzBuilder.h"
#include "BMWBuilder.h"
#include "Director.h"
#include <vector>
#include <iostream>
using std::vector;
using std::string;
using std::cout;
using std::endl;
void DoBenzRun() //没有使用模式时，需要把步骤一条一条的传入模型。
{
cout << "----------生成奔驰模型----------" << endl;
CBenzModel *pBenz = new CBenzModel();
vector<string> seq;
seq.push_back("engine boom");//客户要求run的时候先发动引擎
seq.push_back("start");//启动起来
seq.push_back("stop");//开了一段就停下来
pBenz->SetSequence(&seq);
pBenz->Run();
delete pBenz;
}
void DoBuilder() //使用模式后，由benzBuilder和bmwBuilder来生成，并且使用同样的创建顺序。
{
cout << "----------用同一个顺序，生成模型----------" << endl;
vector<string> seq;
seq.push_back("engine boom");
seq.push_back("start");
seq.push_back("stop");
CBenzBuilder benzBuilder;
benzBuilder.SetSequence(&seq);
CBenzModel *pBenz = dynamic_cast<CBenzModel*>(benzBuilder.GetCarModel());
pBenz->Run();
CBMWBuilder bmwBuilder;
bmwBuilder.SetSequence(&seq);
CBMWModel *pBmw = dynamic_cast<CBMWModel*>(bmwBuilder.GetCarModel());
pBenz->Run();
}
void DoDirector() //使用指导者来封装创建的逻辑，把创建的顺序内聚在指导者类里面。
{
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 _tmain(int argc, _TCHAR* argv[])
{
DoBenzRun();
DoBuilder();
DoDirector();
_CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF | _CRTDBG_ALLOC_MEM_DF);
_CrtDumpMemoryLeaks();
return 0;
}
//CarModel.h
#pragma once
#include <vector>
#include <iostream>
using std::vector;
using std::string;
class CCarModel
{
public:
CCarModel(void);
virtual ~CCarModel(void);
void Run();
void SetSequence(vector<string> *pSeq);
protected:
virtual void Start() = 0;
virtual void Stop() = 0;
virtual void Alarm() = 0;
virtual void EngineBoom() = 0;
private:
vector<string> * m_pSequence;
};
//CarModel.cpp
#include "StdAfx.h"
#include "CarModel.h"
#include <vector>
#include <iostream>
using std::vector;
using std::string;
CCarModel::CCarModel(void)
{
}
CCarModel::~CCarModel(void)
{
}
void CCarModel::SetSequence(vector<string> *pSeq)
{
m_pSequence = pSeq;
}
void CCarModel::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("engine boom") == 0)
{
EngineBoom();
}
}
}
//BenzModel.h
#pragma once
#include "carmodel.h"
class CBenzModel :
public CCarModel
{
public:
CBenzModel(void);
~CBenzModel(void);
protected:
void Start();
void Stop();
void Alarm();
void EngineBoom();
};
//BenzModel.cpp
#include "StdAfx.h"
#include "BenzModel.h"
#include <iostream>
using std::cout;
using std::endl;
CBenzModel::CBenzModel(void)
{
}
CBenzModel::~CBenzModel(void)
{
}
void CBenzModel::Start()
{
cout << "奔驰发动..." << endl;
}
void CBenzModel::Stop()
{
cout << "奔驰停车..." << endl;
}
void CBenzModel::Alarm()
{
cout << "奔驰鸣笛" << endl;
}
void CBenzModel::EngineBoom()
{
cout << "奔驰引擎声音是这样...." << endl;
}
//BMWModel.h
#pragma once
#include "carmodel.h"
class CBMWModel :
public CCarModel
{
public:
CBMWModel(void);
~CBMWModel(void);
protected:
void Start();
void Stop();
void Alarm();
void EngineBoom();
};
//BMWModel.cpp
#include "StdAfx.h"
#include "BMWModel.h"
#include <iostream>
using std::cout;
using std::endl;
CBMWModel::CBMWModel(void)
{
}
CBMWModel::~CBMWModel(void)
{
}
void CBMWModel::Start()
{
cout << "宝马发动..." << endl;
}
void CBMWModel::Stop()
{
cout << "宝马停车..." << endl;
}
void CBMWModel::Alarm()
{
cout << "宝马鸣笛" << endl;
}
void CBMWModel::EngineBoom()
{
cout << "宝马引擎声音是这样...." << endl;
}
//ICarBuilder.h
#pragma once
#include "CarModel.h"
#include <iostream>
#include <vector>
using std::string;
using std::vector;
class ICarBuilder
{
public:
ICarBuilder(void)
{
}
virtual ~ICarBuilder(void)
{
}
virtual void SetSequence(vector<string> *pseq) = 0;
virtual CCarModel * GetCarModel() = 0;
};
//BenzBuilder.h
#pragma once
#include "icarbuilder.h"
#include "CarModel.h"
#include <iostream>
#include <vector>
using std::string;
using std::vector;
class CBenzBuilder :
public ICarBuilder
{
public:
CBenzBuilder(void);
~CBenzBuilder(void);
void SetSequence(vector<string> *pSeq);
CCarModel * GetCarModel();
private:
CCarModel *m_pBenz;
};
//BenzBuilder.cpp
#include "StdAfx.h"
#include "BenzBuilder.h"
#include "BenzModel.h"
CBenzBuilder::CBenzBuilder(void)
{
m_pBenz = new CBenzModel();
}
CBenzBuilder::~CBenzBuilder(void)
{
delete m_pBenz;
}
void CBenzBuilder::SetSequence(vector<string> *pSeq)
{
m_pBenz->SetSequence(pSeq);
}
CCarModel * CBenzBuilder::GetCarModel()
{
return m_pBenz;
}
//BMWBuilder.h
#pragma once
#include "icarbuilder.h"
#include "CarModel.h"
#include <iostream>
#include <vector>
using std::string;
using std::vector;
class CBMWBuilder :
public ICarBuilder
{
public:
CBMWBuilder(void);
~CBMWBuilder(void);
void SetSequence(vector<string> *pSeq);
CCarModel * GetCarModel();
private:
CCarModel *m_pBMW;
};
//BMWBuilder.cpp
#include "StdAfx.h"
#include "BMWBuilder.h"
#include "BMWModel.h"
CBMWBuilder::CBMWBuilder(void)
{
m_pBMW = new CBMWModel();
}
CBMWBuilder::~CBMWBuilder(void)
{
delete m_pBMW;
}
void CBMWBuilder::SetSequence( vector<string> *pSeq )
{
m_pBMW->SetSequence(pSeq);
}
CCarModel * CBMWBuilder::GetCarModel()
{
return m_pBMW;
}
//Director.h
#pragma once
#include "BenzModel.h"
#include "BMWModel.h"
#include "BenzBuilder.h"
#include "BMWBuilder.h"
#include <vector>
using std::vector;
class CDirector
{
public:
CDirector(void);
~CDirector(void);
CBenzModel * GetABenzModel();
CBenzModel * GetBBenzModel();
CBMWModel * GetCBMWModel();
CBMWModel * GetDBMWModel();
private:
vector<string> * m_pSeqence;
CBenzBuilder * m_pBenzBuilder;
CBMWBuilder * m_pBMWBuilder;
};
//Director.cpp
#include "StdAfx.h"
#include "Director.h"
CDirector::CDirector(void)
{
m_pBenzBuilder = new CBenzBuilder();
m_pBMWBuilder = new CBMWBuilder();
m_pSeqence = new vector<string>();
}
CDirector::~CDirector(void)
{
delete m_pBenzBuilder;
delete m_pBMWBuilder;
delete m_pSeqence;
}
CBenzModel * CDirector::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 * CDirector::GetBBenzModel()
{
m_pSeqence->clear();
m_pSeqence->push_back("engine boom");
m_pSeqence->push_back("start");
m_pSeqence->push_back("stop");
m_pBenzBuilder->SetSequence(m_pSeqence);
return dynamic_cast<CBenzModel*>(m_pBenzBuilder->GetCarModel());
}
CBMWModel * CDirector::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 * CDirector::GetDBMWModel()
{
m_pSeqence->clear();
m_pSeqence->push_back("start");
m_pBenzBuilder->SetSequence(m_pSeqence);
return dynamic_cast<CBMWModel*>(m_pBMWBuilder->GetCarModel());
}
建造者模式属于创建型模式，主要关注创建的顺序，不同的顺序，生产的产品略有不同。
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 设计模式C++学习笔记之十（Builder建造者模式）
- 设计模式C++学习笔记之十（Builder建造者模式）
- 设计模式C++学习笔记之十（Builder建造者模式）
- 设计模式C++学习笔记之十（Builder建造者模式）
- 设计模式C++学习笔记之十（Builder建造者模式）
- 设计模式C++学习笔记之十（Builder建造者模式）
- 设计模式C++学习笔记之十二（Command命令模式）
- 步步为营 .NET 设计模式学习笔记 十、Builder(建造者模式)
- 设计模式C++学习笔记之十七（Chain of Responsibility责任链模式）
- 步步为营 .NET 设计模式学习笔记 十、Builder(建造者模式)
- 设计模式C++学习笔记之十四（Iterator迭代器模式）
- 设计模式C++学习笔记之一（Strategy策略模式）
- 设计模式C++学习笔记之八（Adapter适配器模式）
- 设计模式C++学习笔记之十四（Iterator迭代器模式）
- 设计模式C++学习笔记之一（Strategy策略模式）
- 设计模式C++学习笔记之五（Factory Method工厂方法模式）
- 设计模式C++学习笔记之十六（Observer观察者模式）
- 设计模式C++学习笔记之十七（Chain of Responsibility责任链模式）
- 设计模式C++学习笔记之六（AbstractFactory抽象工厂模式）
- 设计模式C++学习笔记之十二（Command命令模式）