前言

建造者模式属于创建型模式，原型模式与工厂模式也归属于这一类。
创建型模式的特点在于，创建新对象，关于创建对象这个概念，在原型模式里面阐述过，创建对象是要深拷贝的，而不是简单的给个引用，指针之类的，这种是没有内存复制的。

下面来看看建造者模式又有什么特点？

1.原理阐述

先看官话：

建造者模式(Builder)：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

说下个人理解：
先看前半句，将一个复杂对象的构建与它的表示分离。那么这里分离的意思其实就是依赖倒置的一种体现。我们在设计模式里面做分离一般都是用接口，这里前半句就提示我们在具体实现的时候要做隔离。

后半句，同样的构建过程…，什么叫同样的构建过程，就是可以认为对象的构建，流程是一致的。比如麦当劳做汉堡，多少度烤多久，制作步骤是什么，这就是流程。

再往后看，同样的构建过程可以创建不同的表示。这里放到C++里面其实就是一种多态的表现。父类的虚函数，子类继承后要重写这个虚函数。

现在做一个总结：建造者模式就是，用依赖倒置的原则，将具有相同流程的对象构建过程放到一个接口类中，具体的实现由具体的子类做，来实现不同的效果。

2.举例

小时候喜欢玩游戏，尤其是小游戏。$4399,7K7K$都是我小时候沉醉的网站。

以前经常玩火柴人系列游戏，火柴人很好画，自己有时候下课发呆也会随便画画，画个火柴人嘛，一个头就是一个圈，四肢与身体，就是一根线嘛，简简单单右手就行。

任何火柴人的原型都是这么画的，都是有固定的头，躯干，四肢，那么这个在建造者模式中就可以认为是同样的构建过程，我们需要用一个接口来封装好，代码如下：

class PersonBuilder
{
public:
	virtual void BuildHead()=0;
	virtual void BuildBody()=0;
	virtual void BuildLeftArm()=0;
	virtual void BuildRightArm()=0;
	virtual void BuildLeftLeg()=0;
	virtual void BuildRightLeg()=0;
};

原理阐述中提到：将一个复杂对象的构建与它的表示分离，那么这个$PersonBuilder$类只是一个构建抽象接口类，具体的表示其实还需要一个新的类。同时，不同的火柴人，脑袋大小，身体结构等都不一样，所以还需要一个具体类去实现这个抽象接口类。
代码如下：

class PersonDisplay
{
public:
	PersonDisplay(PersonBuilder *pb)
	{
		m_pb=pb;
	}
	void CreatePerson()
	{
		m_pb->BuildHead();
		m_pb->BuildBody();
		m_pb->BuildLeftArm();
		m_pb->BuildRightArm();
		m_pb->BuildLeftLeg();
		m_pb->BuildRightLeg();
	}
private:
	PersonBuilder *m_pb;
};
class PersonThin:public PersonBuilder
{
public:
	void BuildHead(){std::cout<<"PersonThin buildHead"<<std::endl;};
	void BuildBody(){std::cout<<"PersonThin buildBody"<<std::endl;};
	void BuildLeftArm(){std::cout<<"PersonThin buildLeftArm"<<std::endl;};
	void BuildRightArm(){std::cout<<"PersonThin buildRightArm"<<std::endl;};
	void BuildLeftLeg(){std::cout<<"PersonThin buildLeftLeg"<<std::endl;};
	void BuildRightLeg(){std::cout<<"PersonThin buildRightLeg"<<std::endl;};
};
class PersonFat:public PersonBuilder
{
public:
	void BuildHead(){std::cout<<"PersonFat buildHead"<<std::endl;};
	void BuildBody(){std::cout<<"PersonFat buildBody"<<std::endl;};
	void BuildLeftArm(){std::cout<<"PersonFat buildLeftArm"<<std::endl;};
	void BuildRightArm(){std::cout<<"PersonFat buildRightArm"<<std::endl;};
	void BuildLeftLeg(){std::cout<<"PersonFat buildLeftLeg"<<std::endl;};
	void BuildRightLeg(){std::cout<<"PersonFat buildRightLeg"<<std::endl;};
};

int main()
{
	PersonThin *a=new PersonThin();
	PersonFat *b=new PersonFat();
	PersonDisplay* m_pda=new PersonDisplay(a);
	PersonDisplay* m_pdb=new PersonDisplay(b);
	//也可以写成这样：
	//PersonDisplay* m_pda=new PersonDisplay(new PersonThin());
	//PersonDisplay* m_pdb=new PersonDisplay(new PersonFat());
	
	m_pda->CreatePerson();
	m_pdb->CreatePerson();
	
	return 0;
}

本来想写伪代码的，一写就基本上都写好了。这里我们看main函数，我们用PersonDisplay这个表示类，把具体的构造过程封装了起来，但是里面的实现实际上是由具体的PersonThin类和PersonFat类去做。

总结

建造者模式适合于那种流程相对固定，且最后的需求是创建对象的场景。当然了，它本身是一个创建者模式，不创建对象的话，那就不能称之为创建者模式了。

建造者模式两个点，流程固定，依赖倒置。