设计模式—建造者模式（九）

        软件领域中的设计模式的重要性不言而喻。设计模式中运用了面向对象编程语言的重要特性：封装、继承、多态。虽然知道这些特性的定义但是并没有做到真正的理解，这样特性有什么作用？用于什么场合中等等问题，带着疑问开始学习设计模式，主要参考《大话设计模式》和《设计模式:可复用面向对象软件的基础》两本书。

        建造者模式（生成器模式）：是将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示

        建造者模式通常包括下面几个角色：

        1. builder：给出一个抽象接口，以规范产品对象的各个组成成分的建造。这个接口规定要实现复杂对象的哪些部分的创建，并不涉及具体的对象部件的创建。

        2.ConcreteBuilder：实现Builder接口，针对不同的商业逻辑，具体化复杂对象的各部分的创建。 在建造过程完成后，提供产品的实例。

        3. Director：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。

        4. Product：要创建的复杂对象。

#include <string>
#include <iostream>
#include <vector>
using namespace std;
//最终的产品类
class Product
{
private:
	vector<string> m_product;
public:
	void Add(string str)
	{
		m_product.push_back(str);
	}
	void Show()
	{
		cout << "产品组件如下：";
		for (auto p:m_product)
			cout << p << " ";	
		cout << endl;
	}
};

//建造者基类 
class Builder
{
public:
	//包含产品所构建的所有方法
	virtual void BuilderA() = 0;
	virtual void BuilderB() = 0;
	virtual Product* GetResult() = 0;
};
//第一种建造方式
class ConcreteBuilder1 : public Builder
{
private:
	Product* m_product;
public:
	ConcreteBuilder1()
	{
		m_product = new Product();
	}
	virtual void BuilderA()
	{
		m_product->Add("可乐");
	}
	virtual void BuilderB()
	{
		m_product->Add("可乐瓶");
	}
	virtual Product* GetResult()
	{
		return m_product;
	}
};
//第二种建造方式
class ConcreteBuilder2 : public Builder
{
private:
	Product * m_product;
public:
	ConcreteBuilder2()
	{
		m_product = new Product();
	}
	virtual void BuilderA()
	{
		m_product->Add("雪碧");
	}
	virtual void BuilderB()
	{
		m_product->Add("雪碧瓶");
	}
	virtual Product* GetResult()
	{
		return m_product;
	}
};

//指挥者类
class Direct
{
public:
	//根据用户需求创建产品
	void Construct(Builder* temp)
	{
		temp->BuilderA();
		temp->BuilderB();
	}
};

//客户端
int main()
{
	Direct *p = new Direct();
	Builder* b1 = new ConcreteBuilder1(); //具体建造类1
	Builder* b2 = new ConcreteBuilder2(); //具体建造类2

	p->Construct(b1);               //调用第一种方式
	Product* pb1 = b1->GetResult();
	cout << "饮料1—";
	pb1->Show();

	p->Construct(b2);               //调用第二种方式
	Product * pb2 = b2->GetResult();
	cout << "饮料2—";
	pb2->Show();
	return 0;
}

        小结：

        1、建造者模式是将一个复杂对象的创建过程给封装起来，客户只需要知道可以利用对象名或者类型就能够得到一个完整的对象实例，而不需要关心对象的具体创建过程。

        2、建造者模式将对象的创建过程与对象本身隔离开了，使得细节依赖于抽象，符合依赖倒置原则。可以使用相同的创建过程来创建不同的产品对象。

        利用建造者模式建立一个瘦人和一个胖人例子如下：

#include <string>
#include <iostream>
#include <vector>
using namespace std;
//创建人物 基类 相当于产品类
class Person
{
public:
	virtual void CreateHead() = 0;
	virtual void CreateHand() = 0;
	virtual void CreateBody() = 0;
	virtual void CreateFoot() = 0;
};
//创建人物具体类1
class ThinPerson : public Person
{
public:
	virtual void CreateHead()
	{
		cout << "小头" << endl;
	}
	virtual void CreateHand()
	{
		cout << "小手" << endl;
	}
	virtual void CreateBody()
	{
		cout << "小个子" << endl;
	}
	virtual void CreateFoot()
	{
		cout << "小脚" << endl;
	}
};
//创建人物具体类2
class FatPerson : public Person
{
public:
	virtual void CreateHead()
	{
		cout << "大头" << endl;
	}
	virtual void CreateHand()
	{
		cout << "大手" << endl;
	}
	virtual void CreateBody()
	{
		cout << "大个子" << endl;
	}
	virtual void CreateFoot()
	{
		cout << "大脚" << endl;
	}
};
//指挥者类
class Direct
{
private:
	Person* p;
public:
	Direct(Person* temp)//构造函数
	{
		p = temp;
	}
	void Create()
	{
		p->CreateHead();
		p->CreateBody();
		p->CreateHand();
		p->CreateFoot();
	}
};

//客户端代码：
int main()
{

	Person *p = new FatPerson();
	Direct *d = new Direct(p); //创建胖人
	cout << "创建偏胖人物：";
	d->Create();

	Person *Per = new ThinPerson();
	Direct *dir = new Direct(Per);// 创建瘦人
	cout << "创建偏瘦人物：";
	dir->Create();

	delete d;
	delete p;
	delete dir;
	delete Per;
	return 0;
}