设计模式-------------建造者模式（生成器模式）

建造者模式的优点：

在当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时适用。

结构图如下：

需要为具体的产品类维护一个建造者基类，然后在建造者子类中完成具体的实现，最后在指挥者类(Directer Class)中完成对接口的调用。

具体代码如下：

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


//最终产品类
class Product{
private:
	vector<string> m_Product;

public:
	void Add(string strtemp){
		m_Product.push_back(strtemp);
	}

	void Show(){
		vector<string>::iterator p = m_Product.begin();
		while (p != m_Product.end())
		{
			cout << *p << endl;
			p++;
		}
	}
};


//建造者基类
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("One");

	}

	virtual void BuilderB(){
		m_product->Add("Two");
	}


	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("A");
	}


	virtual void BuilderB(){

		m_product->Add("B");
	}

	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;
	Builder *b2 = new ConcreteBuilder2;


	p->Construct(b1);
	Product* pb1 = b1->GetResult();
	pb1->Show();


	p->Construct(b2);
	Product* pb2 = b2->GetResult();
	pb2->Show();
	getchar();
	getchar();
	return 0;
}