设计模式之建造者模式

（一）概念：

Builder模式也叫建造者模式或者生成器模式，是由GoF提出的23种设计模式中的一种。Builder模式是一种对象创建型模式之一，用来隐藏复合对象的创建过程，它把复合对象的创建过程加以抽象，通过子类继承和重载的方式，动态地创建具有复合属性的对象。
对象的创建：Builder模式是为对象的创建而设计的模式- 创建的是一个复合对象：被创建的对象为一个具有复合属性的复合对象- 关注对象创建的各部分的创建过程：不同的工厂（这里指builder生成器）对产品属性有不同的创建方法
 class A
{
    private：
     B *b;
}

（二）模式中包含的角色及其职责

1) Builder：为创建产品各个部分，统一抽象接口。
2) ConcreteBuilder：具体的创建产品的各个部分，部分A， 部分B，部分C。
3) Director：构造一个使用Builder接口的对象。
4) Product：表示被构造的复杂对象。
ConcreteBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

（三）适用情况

一个对象的构建比较复杂，将一个对象的构建和对象的表示进行分离。

（四）建造者模式的实现

#include 
   
   
    
    
using namespace std;
#include 
    
    
     
     

class House 
{
public:
	void SetWall(string wall) 
	{ 
		m_wall = wall; 
	}
	string GetWall()
	{
		cout << m_wall << endl;
		return m_wall;
	}

	void SetDoor(string door) 
	{ 
		m_door = door; 
	}
	string GetDoor()
	{
		cout << m_door << endl;
		return m_door;
	}

	void SetWindows(string windows) 
	{ 
		m_windows = windows; 
	}
	string GetWindows()
	{
		cout << m_windows << endl;
		return m_windows;
	}
private:
	string m_wall;
	string m_door;
	string m_windows;
};

class Build
{
public:
	virtual void buidWall() = 0;
	virtual void buidDoor() = 0;
	virtual void buidWindows() = 0;
	virtual House *getHouse() = 0;
};

// 建造别墅的工程队
class BuildVilla: public Build
{
public:
	BuildVilla()
	{
		house = new House;
	}
public:
    void buidWall() 
	{
		house->SetWall("别墅的墙");
	}
	void buidDoor() 
	{
		house->SetDoor("别墅的门");
	}
	void buidWindows() 
	{
		house->SetWindows("别墅的窗户");
	}
	House *getHouse() 
	{
		return house;
	}
private:
	House *house;
};

// 建造普通房的工程队
class BuildCommonHouse: public Build
{
public:
	BuildCommonHouse()
	{
		house = new House;
	}
public:
	void buidWall() 
	{
		house->SetWall("普通房的墙");
	}
	void buidDoor() 
	{
		house->SetDoor("普通房的门");
	}
	void buidWindows() 
	{
		house->SetWindows("普通房的窗户");
	}
	House *getHouse() 
	{
		return house;
	}
private:
	House *house;
};

// 设计者，包工头
class Director
{
public:
	void SetBuild(Build *build)
	{
		this->build = build;
	}

	void Construct()
	{
		build->buidWall();
		build->buidWindows();
		build->buidDoor();
	}

	House *GetHouse()
	{
		return build->getHouse();
	}
private:
	Build *build;
};

int main()
{
	House    *h = NULL;
	Director *d = new Director;
	Build      *b = NULL;

	//建别墅
	b = new BuildVilla();
	d->SetBuild(b);
	d->Construct();
	h = d->GetHouse();
	h->GetWall();
	h->GetWindows();
	h->GetDoor();

	delete h;
	delete b;

	b = new BuildCommonHouse;
	// d = new Director(b);
	d->SetBuild(b);
	d->Construct();
	h = d->GetHouse();
	h->GetWall();
	h->GetWindows();
	h->GetDoor();

	delete h;
	delete d;
	delete b;


	return 0;
}
    
    
   
   

（五）建造者模式和工厂模式的区别

Factory模式中：
1、有一个抽象的工厂。
2、实现一个具体的工厂---汽车工厂。
3、工厂生产汽车A，得到汽车产品A。
4、工厂生产汽车B，得到汽车产品B。  
这样做，实现了购买者和生产线的隔离。强调的是结果。      
Builder模式:
1、引擎工厂生产引擎产品，得到汽车部件A。
2、轮胎工厂生产轮子产品，得到汽车部件B。
3、底盘工厂生产车身产品，得到汽车部件C。
4、将这些部件放到一起，形成刚好能够组装成一辆汽车的整体。
5、将这个整体送到汽车组装工厂，得到一个汽车产品。
这样做，目的是为了实现复杂对象生产线和其部件的解耦。强调的是过程
两者的区别在于：
Factory模式不考虑对象的组装过程，而直接生成一个我想要的对象。
Builder模式先一个个的创建对象的每一个部件，再统一组装成一个对象。
Factory模式所解决的问题是，工厂生产产品。
而Builder模式所解决的问题是工厂控制产品生成器组装各个部件的过程，然后从产品生成器中得到产品。