设计模式---生成器

一、功能

    将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

二、示例代码

namespace DesignPattern_Builder
{
	class Product1 { 

		PartA m_partA;

		PartB m_partB;

		PartC m_partC;

	} ;
	class Product2 {

		PartA m_partA;

		PartB m_partB;
		PartC m_partC;

	} ;

	// class Builder
	class Builder	//抽象基类
	{
	public:
		virtual void BuilderPartA() {}	//提供缺省实现
		virtual void BuilderPartB() {}
		virtual void BuilderPartC() {}
	protected:
		Builder() {}
	} ;

	// class ConcreteBuilder1
	class ConcreteBuilder1 : public Builder	//创建Product1
	{
	public:
		ConcreteBuilder1() : _product(NULL) {}

		virtual void BuilderPartA() { /*...*/ }	
		virtual void BuilderPartB() { /*...*/ }
		virtual void BuilderPartC() { /*...*/ }

		virtual Product1* GetProduct1() { return _product ; }	//返回创建的Product1对象
	private:
		Product1 *_product ;
	} ;

	// class ConcreteBuilder2
	class ConcreteBuilder2 : public Builder	//创建Product2
	{
	public:
		ConcreteBuilder2() : _product(NULL) {}

		virtual void BuilderPartA() { /*...*/ }	
		virtual void BuilderPartB() { /*...*/ }
		virtual void BuilderPartC() { /*...*/ }

		virtual Product2* GetProduct2() { return _product ; }	//返回创建的Product2对象
	private:
		Product2 *_product ;
	} ;

	// class Director
	class Director
	{
	public:
		//创建对象(Director并不知道具体创建出来的对象是什么样的，只有调用该函数的client知道)
		void Construct(Builder *builder)
		{
			builder->BuilderPartA() ;
			builder->BuilderPartB() ;
			builder->BuilderPartC() ;
		}
	} ;
}

客户端代码：
{
	using namespace DesignPattern_Builder ;

	Director director ;

	// 创建第一种对象
	ConcreteBuilder1 *pBuilder1 = new ConcreteBuilder1() ;
	director.Construct(pBuilder1) ;
	Product1 *product1 = pBuilder1->GetProduct1() ;

	// 创建第二种对象
	ConcreteBuilder2 *pBuilder2 = new ConcreteBuilder2() ;
	director.Construct(pBuilder2) ;
	Product2 *product2 = pBuilder2->GetProduct2() ;
}

用通俗的话解释“功能：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。”。 上述客户端示例代码中，我们原本要创建 Product1， Product2 的2个不同对象，因为这2个对象都是由PartA, PartB, PartC组合创建而来，不同的是，其中内容不同，即表示不同。

所以，我们可以使用生成器模式，统一Product1， Product2对象的创建过程，

对客户端代码：

director.Construct(pBuilder2) ;

生成器模式代码：

// class Builder
class Builder	//抽象基类
{
public:
	virtual void BuilderPartA() {}	//提供缺省实现
	virtual void BuilderPartB() {}
	virtual void BuilderPartC() {}
protected:
	Builder() {}
} ;

class Director
{
public:
	//创建对象(Director并不知道具体创建出来的对象是什么样的，只有调用该函数的client知道)
	void Construct(Builder *builder)
	{
		builder->BuilderPartA() ;
		builder->BuilderPartB() ;
		builder->BuilderPartC() ;
	}
} ;

而把不同的表示放在具体的 class ConcreteBuilder1, class ConcreteBuilder2 中：

virtual void BuilderPartA() { /*...*/ }	
virtual void BuilderPartB() { /*...*/ }
virtual void BuilderPartC() { /*...*/ }

优点：客户端代码创建复杂对象时，逻辑简单，不用考虑对象的表示细节。

缺点：复杂对象不同表示细节都需要抽取为抽象接口，并在具体子类中实现细节表示。