C++设计模式新解二 建造者模式+工厂模式

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

建造者模式的角色包括：

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

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

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

Product：要创建的复杂对象。

先看一段代码：

//Product类
class Product{
	vector parts;
public:
	void Add(const string part)
	{
		parts.push_back(part);
	}
	
	void Show() const
	{
		for(int i = 0; i < parts.size(); ++i)
		{
			cout << parts[i] << endl;
		}
	}
};

class Builder
{
	public:
		virtual void BuildHead() = 0;
		virtual void BuildBody() = 0;
		virtual void BuildHand() = 0;
		virtual Product GetResult() = 0;
}

//具体胖人创建类
class FatPersonBuilder: public Builder{
private:
	Product product;
	
public:
	virtual void BuildHead()
	{
		product.Add("胖人人头");
	}
	
	virtual void BuildBody()
	{
		product:Add("胖人身体");
	}
	
	virtual void BuildHand()
	{
		product:Add("胖人手")；
	}
	
	virtual void BuildFeet()
	{
		product:Add("胖人脚");
	}
	
	virtual Product GetResult()
	{
		return product;
	}
}

//瘦人类
class ThinPersonBuilder: public Builder{
private:
	Product product;
public:
	virtual void BuildHead()
	{
		product.Add("瘦人人头");
	}
	
	virtual void BuildBody()
	{
		product.Add("瘦人身体");
	}
	
	virtual void BuildHand()
	{
		product.Add("瘦人手");
	}
	
	virtual void BuildFeet()
	{
		product.Add("瘦人脚");
	}
	
	virtual Product GetResult()
	{
		return product;
	}
}

//Director类
class Director{
public:
	void Construct(Builder & builder)
	{
		builder.BuildHead();
		builder.BuildBody();
		builder.BuildHand();
		builder.BuildFeet();
	}
}


int main()
{
	Director * director = new Director();
	Builder * b1 = new FatPersonBuilder();
	Builder * b2 = new ThinPersonBuilder();
	
	director->Construct(*b1);
	Product p1 =  b1->GetResult();
	p1.Show();
	return 0;
}

我们先从Director来分析，Director里的 Construct() 函数保证了一定会创造 头，身体，手，脚。

一旦出现其他种类的人，也不用去修改原来的代码，而直接创建新的Builder就行了，这符合面向对象的开闭原则，即扩展代码打开，修改代码关闭原则。

根据 Builder提供的BuildXXX函数，与director提供的Construct函数，我们将构建与表示分离开了，BuildXXX是表示，Construct是构建，同样的构建过程却创建了不同的表示。

使用建造者模式的好处是：

1.客户端不用知道产品内部的细节

2.具体的建造者类之间是相互独立的，有利于扩展

3.由于具体的建造者之间是独立的，可以逐步细化，而不影响其他模块

何时使用建造者模式：

1.创建一些复杂对象，这些对象内部组成构件间的建造顺序是稳定的，但是对象内部组成构件面临着复杂变化。

2.要创建的复杂对象的算法，独立于该对象的组成部分，也独立于组成部分的装配方法时。

我们发现 建造者模式和工厂模式相当接近：

上一段工厂代码，

public class Factory{
    public static ISample creator(int which){
        if (which==1)
            return new SampleA();
        else if (which==2)
            return new SampleB();
    }
}

那么 我们发现区别了 工厂作为构建的代理类，并没有做太多工作，仅仅是调用该复杂对象的构造函数，仅此而已。

建造者模式注重零部件的组装，而工厂模式则是注重零部件的创建。

比如要组装一个玩具

工厂里 主要负责生产玩具的部位，

而建造者则把这些部位拼接在一起。

所以

//瘦人类
class ThinPersonBuilder: public Builder{
private:
	Product product;
public:

	virtual void BuildHead()
	{
		product.Add("瘦人人头");
	}
	
	virtual void BuildBody()
	{
		product.Add("瘦人身体");
	}
	
	virtual void BuildHand()
	{
		product.Add("瘦人手");
	}
	
	virtual void BuildFeet()
	{
		product.Add("瘦人脚");
	}
}

//这里也可以改成使用工厂方法实现

FactoryThin()
{
	public static string create(int which)
	{
		if(which == 1)
		{
			return "瘦人头";
		}
		else if(which == 2)
		{
			return "瘦人身体";
		}
		else if(which == 3)
		{
			return "瘦人手";
		}
		else if(which == 4)
		{
			return "瘦人脚";
		}
	}
}

class ThinPersonBuilder: public Builder{
private:
	Product product;
public:
	product.Add(FactoryThin.create(1))
	product.Add(FactoryThin.create(1))
	product.Add(FactoryThin.create(1))
	product.Add(FactoryThin.create(1))
	
	virtual Product GetResult()
	{
		return product;
	}
}

这就是一个建造者跟工厂模式合作的很好例子