设计模式之建造者模型

 首先看一个比较通用的模型例子：

builder.h

//设计模式之builder模式
/*
作用：将一个复杂对象的构建与它的表示分离，使同样的构建过程创建不同的表示
*/
//虚拟基类，所有builder的基类，提供不同部分的构建接口
class builder
{
public:
	builder(){};
	virtual ~builder(){};

	//提供构建接口
	virtual void builderA() = 0;
	virtual void builderB() = 0;
};

//使用builder构建产品，构建产品的过程都一致，但是不同的builder会有不同的表现
//这个不同的实现通过不同的builder派生类来实现，存有一个builder的指针，多态调用
class director
{//
public:
	director(builder *pbuilder);
	virtual ~director();

	void construct();
private:
	builder *pBuilder;
};

class concretebuilder1:public builder
{
public:
	concretebuilder1(){}
	virtual ~concretebuilder1(){}
	virtual void builderA();
	virtual void builderB();
};
class concretebuilder2:public builder
{
public:
	concretebuilder2(){}
	virtual ~concretebuilder2(){}

	virtual void builderA();
	virtual void builderB();
};

builder.cpp

#include "builder.h"
#include <stdio.h>

void concretebuilder1::builderA()
{
	printf("builderA by concretebuilder1\n");
}

void concretebuilder1::builderB()
{
	printf("builderB by concretebuilder1\n");
}

void concretebuilder2::builderA()
{
	printf("builderA by concretebuilder2\n");
}

void concretebuilder2::builderB()
{
	printf("builderB by concretebuilder2\n");
}

director::director(builder *pbuilder)
{
	this->pBuilder = pbuilder;
}
director::~director()
{
	delete pBuilder;
	pBuilder = NULL;
}

void director::construct()
{
	pBuilder->builderA();
	pBuilder->builderB();
}


void main()
{
	builder *pbuilder1 = new concretebuilder1;
	director *pdirector = new director(pbuilder1);
	pdirector->construct();

	builder *pbuilder2 = new concretebuilder2;
	director *pdirector2 = new director(pbuilder2);
	pdirector2->construct();

	delete pdirector;
	delete pdirector2;

}

使用一个具体的例子来理解builder模型：

carbuilder.h

//
/*
客户模型：
carmodel:汽车模型
benmodel:奔驰汽车
bmwmodel:宝马汽车
carbuilder:建造者接口
benbuilder：奔驰建造者
bmwbuilder:宝马建造者
director：导演
*/

#include <vector>
#include <string>
#include <iostream>
using namespace std;

//首先虚拟出一个汽车模型
class carmodel
{
public:
	carmodel();
	virtual ~carmodel();
	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;
};
//根据汽车模型构建奔驰汽车
class benmodel:public carmodel
{
public:
	benmodel();
	~benmodel();
protected:
	void Start();
	void Stop();
	void Alarm();
	void EngineBoom();

};
//根据汽车模型构建宝马汽车
class bmwmodel:public carmodel
{
public:
	bmwmodel();
	~bmwmodel();
protected:
	void Start();
	void Stop();
	void Alarm();
	void EngineBoom();

};
//虚拟出一个汽车的建造者模型
class carbuilder
{
public:
	carbuilder()
	{

	}
	virtual ~carbuilder()
	{

	}
	virtual void SetSequence(vector<string> *pSeq) = 0;
	virtual carmodel* GetCarModel() = 0;
};

class benbuilder:public carbuilder
{
public:
	benbuilder();
	~benbuilder();
	void SetSequence(vector<string> *pSeq);
	carmodel* GetCarModel();
private:
	carmodel *pBen;
};
class bmwbuilder:public carbuilder
{
public:
	bmwbuilder();
	~bmwbuilder();
	void SetSequence(vector<string> *pSeq);
	carmodel* GetCarModel();
private:
	carmodel *pBmw;
};


class director
{
public:
	director();
	~director();
	benmodel* GetABenModel();
	benmodel* GetBBenModel();
	bmwmodel* GetCBmwModel();
	bmwmodel* GetDBmwModel();
private:
	vector<string> *pSequence;
	benbuilder *pBen;
	bmwbuilder *pBmw;
};

carbuilder.cpp

#include"builder.h"
carmodel::carmodel()
{

}
carmodel::~carmodel()
{

}
void carmodel::SetSequence(vector<string> *pSeq)
{
	m_pSequence = pSeq;
}
void carmodel::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();
		}
	}
}

benmodel::benmodel()
{

}
benmodel::~benmodel()
{

}
void benmodel::Start()
{
	cout<<"ben start..."<<endl;
}
void benmodel::Stop()
{
	cout<<"ben stop..."<<endl;
}
void benmodel::Alarm()
{
	cout<<"ben alarm..."<<endl;
}
void benmodel::EngineBoom()
{
	cout<<"ben engineboom..."<<endl;
}

bmwmodel::bmwmodel()
{

}
bmwmodel::~bmwmodel()
{

}
void bmwmodel::Start()
{
	cout<<"bmw start..."<<endl;
}
void bmwmodel::Stop()
{
	cout<<"bmw stop..."<<endl;
}
void bmwmodel::Alarm()
{
	cout<<"bmw alarm..."<<endl;
}
void bmwmodel::EngineBoom()
{
	cout<<"bmw engineboom..."<<endl;
}

benbuilder::benbuilder()
{
	//在构造函数中创建奔驰汽车的模型
	pBen = new benmodel();
}
benbuilder::~benbuilder()
{

}
carmodel* benbuilder::GetCarModel()
{
	return pBen;
}
void benbuilder::SetSequence(vector<string> *pSeq)
{
	pBen->SetSequence(pSeq);
}

bmwbuilder::bmwbuilder()
{
	//在构造函数中创建宝马汽车的模型
	pBmw = new bmwmodel();
}
bmwbuilder::~bmwbuilder()
{

}
carmodel* bmwbuilder::GetCarModel()
{
	return pBmw;
}
void bmwbuilder::SetSequence(vector<string> *pSeq)
{
	pBmw->SetSequence(pSeq);
}

director::director()
{
	pBen = new benbuilder();
	pBmw = new bmwbuilder();
	pSequence = new vector<string>();
}
director::~director()
{
	delete pBen;
	delete pBmw;
	delete pSequence;
}
benmodel * director::GetABenModel()
{
	pSequence->clear();
	pSequence->push_back("start");
	pSequence->push_back("stop");
	pBen->SetSequence(pSequence);
	return dynamic_cast<benmodel*>(pBen->GetCarModel());
}
benmodel * director::GetBBenModel()
{
	pSequence->clear();
	pSequence->push_back("start");
	pSequence->push_back("Alarm");
	pSequence->push_back("Stop");
	pBen->SetSequence(pSequence);
	return dynamic_cast<benmodel*>(pBen->GetCarModel());
}
bmwmodel *director::GetCBmwModel()
{
	pSequence->clear();
	pSequence->push_back("start");
	pSequence->push_back("stop");
	pBmw->SetSequence(pSequence);
	return dynamic_cast<bmwmodel*>(pBmw->GetCarModel());
}

bmwmodel *director::GetDBmwModel()
{
	pSequence->clear();
	pSequence->push_back("start");
	pSequence->push_back("Engineboom");
	pBmw->SetSequence(pSequence);
	return dynamic_cast<bmwmodel*>(pBmw->GetCarModel());
}
int main()
{
	director *pdir = new director;

	benmodel *pben = pdir->GetABenModel();
	pben->Run();

	bmwmodel *pbmw = pdir->GetCBmwModel();
	pbmw->Run();
	delete pdir;
	return 0;
}

非常推荐一个例子：http://blog.csdn.net/wuzhekai1985/article/details/6667467