建造者模式又叫生成器模式，它把复合对象复杂的创建过程加以抽象，通过子类继承和重载的方式，动态地创建具有复合属性的对象。即将产品的内部表象和产品的生成过程分割开来，从而使用一个建造过程生成具有不同内部表象的产品对象。

建造者模式和工厂模式的区别：

工厂模式：

  1. 有一个抽象工厂

  2. 实现一个具体工厂-汽车工厂

  3. 汽车工厂A生产汽车A，得到汽车A

  4. 汽车工厂B生产汽车B，得到汽车B

这样做实现了购买者和生产线的隔离，强调的是结果。

建造者模式：

  1. 引擎工厂生产引擎产品，得到汽车部件A

  2. 轮胎工厂生产轮胎产品，得到汽车部件B

  3. 底盘工厂生产底盘产品，得到汽车部件C

  4. 将这些部件组合在一起，得到汽车产品

这样做目的是为了实现复杂独享生产线和其部件的解耦，强调的是过程。

就像建房子的步骤都是先造墙，再造窗户，最后造门，但是最后造出来的是公寓还是别墅，就要靠具体的细节实现了。

优点： 1、建造者独立，易扩展。 2、便于控制细节风险。

缺点： 1、产品必须有共同点，范围有限制。 2、如内部变化复杂，会有很多的建造类。

示例代码如下：

#include <iostream>
#include <string>

using namespace std;

/* 复杂对象-房子 */
class House
{
public:
	void setDoor(string door)
	{
		m_door = door;
	}
	void setWall(string wall)
	{
		m_wall = wall;
	}
	void setWindow(string window)
	{
		m_window = window;
	}
	
	string getDoor()
	{
		cout << "我的门是:" << m_door << endl;
		return m_door;
	}
	string getWall()
	{
		cout << "我的墙是:" << m_door << endl;
		return m_wall;
	}
	string getWindow()
	{
		cout << "我的窗户是:" << m_door << endl;
		return m_window;
	}
private:
	string m_door;
	string m_wall;
	string m_window;
};

/* 抽象建筑队 */
class Builder
{
public:
	virtual void buildWall() = 0;
	virtual void buildDoor() = 0;
	virtual void buildWindow() = 0;
	virtual House* getHouse() = 0;
};

/* 具体公寓建筑队 */
class FlatBuilder:public Builder
{
public:
	FlatBuilder()
	{
		m_House = new House;
	}
	virtual void buildWall()
	{
		m_House->setWall("公寓墙");
	}
	virtual void buildDoor()
	{
		m_House->setDoor("公寓门");
	}
	virtual void buildWindow()
	{
		m_House->setWindow("公寓窗户");
	}
	virtual House* getHouse()
	{
		cout << "我的公寓造好了"  << endl;
		return m_House;
	}
private:
	House* m_House;
};

/* 具体别墅建筑队 */
class VillaBuilder :public Builder
{
public:
	VillaBuilder()
	{
		m_House = new House;
	}
	virtual void buildWall()
	{
		m_House->setWall("别墅墙");
	}
	virtual void buildDoor()
	{
		m_House->setDoor("别墅门");
	}
	virtual void buildWindow()
	{
		m_House->setWindow("别墅窗户");
	}
	virtual House* getHouse()
	{
		cout << "我的800平方的别墅造好了" << endl;
		return m_House;
	}
private:
	House* m_House;
};

/* 要建造的房子的主人 */
class Director
{
public:
	/* 根据找的建筑队，确定要建造什么样的房子 */
	Director(Builder* b)
	{
		builder = b;
	}
	/* 开始制造房子 */
	void Construct()
	{
		builder->buildWall();
		builder->buildWindow();
		builder->buildDoor();
	}
private:
	Builder* builder;
};

int main()
{
	House* house = NULL;
	Builder* Villabuilder = NULL;
	Builder* Flatbuilder = NULL;
	Director* director = NULL;
	
	Villabuilder = new VillaBuilder;
	Flatbuilder = new FlatBuilder;


	director = new Director(Villabuilder);
	director->Construct();
	house = Villabuilder->getHouse();
	house->getDoor();
	house->getWall();
	house->getWindow();
	
	delete director;

	director = new Director(Flatbuilder);
	director->Construct();
	house = Flatbuilder->getHouse();
	house->getDoor();
	house->getWall();
	house->getWindow();



	delete house;
        delete Villabuilder;
	delete Flatbuilder ;
	delete director;
	system("pause");
	return 0;
}

运行结果如下：