设计模式(9)--建造者模式

//建造者模式(或叫生成器模式)，将一个复杂对象的构建与它的表示愤慨，使得同样的构建过程可以创建不同的表示。
//如果我们用了建造者模式，那么用户就只需指定需要建造的类型就可以得到它们，而具体建造的过程和细节就不需知道了。

//抽象类
class PersonBuilder
{
protected:
	char * _pg; //Graphics * _pg; 用char来代替，通过编译
	char * _pp; // Pen * _pp;
public:
	PersonBuilder(char *pg, char * pp)
	{
		_pg = pg;
		_pp = pp;
	}
	virtual void BuildHead();
	virtual void BuildBody();
	virtual void BuildArmLeft();
	virtual void BuildArmRight();
};

//瘦子类
class PersonThinBuilder : public PersonBuilder
{
public:
	PersonThinBuilder(char * pg, char * pp) :
		PersonBuilder(pg, pp)
	{}
	virtual void BuildHead()
	{
		//fun
	}
	virtual void BuildBody()
	{
		//fun
	}
	virtual void BuildArmLeft()
	{
		//fun
	}
	virtual void BuildArmRight()
	{
		//fun
	}
};

//胖子类
class PersonFatBuilder : public PersonBuilder
{
public:
	PersonFatBuilder(char * pg, char * pp) :
		PersonBuilder(pg, pp)
	{}
	virtual void BuildHead(){}
	virtual void BuildBody(){}
	virtual void BuildArmLeft(){}
	virtual void BuildArmRight(){}
};

//指挥者类
class PersonDirector
{
private:
	PersonBuilder *_ppb;
public:
	PersonDirector(PersonBuilder * ppb)
	{
		_ppb = ppb;
	}

	void CreatePerson()
	{
		_ppb->BuildHead();
		_ppb->BuildBody();
		_ppb->BuildArmLeft();
		_ppb->BuildArmRight();
	}
	//PersonDirector类的目的就是根据用户的选择一步步建造人物，而建造的过程在指挥者这里完成。
};

 

//9.建造者模式
//ver2
//Builder : 是为创建一个Product对象的各个部件指定的抽象接口。
//ConcreteBuilder : 它是具体构造者,构造和装配各个部件。
//Product : 当然就是那些具体的人物，产品角色。
//Director : 它是构建一个使用Builder接口的对象。

//Product类--产品类，由多个部件组成.
class Product
{
private:
	list<string> myList;
public:
	void Add(string strPart)
	{
		myList.push_back(strPart);
	}
	void Show()
	{
		list<string>::iterator it = myList.begin();
		for ( ; it != myList.end(); ++it )
		{
			printf("%s",*it);
		}
	}
};

//Build 抽象建造者类
class Builder
{
public:
	virtual void BuildPartA(){}
	virtual void BuildPartB(){}
	virtual Product* GetRseult(){ return NULL;}
};

//ConcreteBuilder1 具体建造者类
class ConcreteBuilder1 : public Builder
{
private:
	Product * pp;
public:
	ConcreteBuilder1()
	{
		if (pp == NULL)
		{
			pp = new Product;
		}
	}
	void BuildPartA()
	{
		pp->Add("部件A");
	}
	void BuildPartB()
	{
		pp->Add("部件B");
	}
	Product* GetResult()
	{
		return pp;
	}
};

//ConcreteBuilder2 具体建造者类
class ConcreteBuilder2 : public Builder
{
private:
	Product * pp;
public:
	ConcreteBuilder2()
	{
		if (pp == NULL)
		{
			pp = new Product;
		}
	}
	void BuildPartA()
	{
		pp->Add("部件X");
	}
	void BuildPartB()
	{
		pp->Add("部件Y");
	}
	Product* GetResult()
	{
		return pp;
	}
};

//Director 指挥者类
class Director
{
public:
	void Construct(Builder *pb)
	{
		pb->BuildPartA();
		pb->BuildPartB();
	}
};

void main2()
{
	Director * pdir = new Director();
	Builder * pb1 = new ConcreteBuilder1();
	Builder * pb2 = new ConcreteBuilder2();

	pdir->Construct(pb1);
	Product * p1 = pb1->GetRseult(); //指挥者用ConcreteBuilder1的方法来建造产品。
	p1->Show();

	pdir->Construct(pb2);
	Product * p2 = pb2->GetRseult(); //指挥者用ConcreteBuilder2的方法来建造产品。
	p2->Show();
}

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