建造者模式

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

建造者模式主要用于创建一些复杂的对象，这些对象内部构建间的建造顺序通常是稳定的，但对象内部的构建通常面临复杂的变化。

都将建造者模式与装饰模式比较，一个是过程固定内容不同的建造，一个是动态的装饰。这两个模式放在一起比较，是因为它们两个明显的不同，一个过程固定，一个动态变化。

个人觉得还有一个模式可以比较，那就是模版模式，仔细对比你会发现，将建造者模式的Director去掉的话，就是一个模板模式。

建造者模式类关系图：

c++实现代码：

#include<iostream>
#include<string>
#include<vector>

using namespace std;

class Product
{
public:
	Product()
	{}
	void add(string part);
	void show();
private:
	vector<string> parts;
};

void Product::add(string part)
{
	parts.push_back(part);
}

void Product::show()
{
	for (vector<string>::const_iterator iter = parts.begin(); iter != parts.end(); iter++)
		cout << *iter << "  ";
	cout << endl;
}

class Builder
{
public:
	virtual void buildPartA() = 0;
	virtual void buildPartB() = 0;
	virtual Product getResult() = 0;

};

class BuilderA : public Builder
{
public:
	BuilderA()
	{}
	void buildPartA();
	void buildPartB();
	Product getResult();
private:
	Product product;
};

void BuilderA::buildPartA()
{
	product.add("PartA");
}

void BuilderA::buildPartB()
{
	product.add("PartB");
}

Product BuilderA::getResult()
{
	return product;
}

class BuilderB : public Builder
{
public:
	BuilderB()
	{}
	void buildPartA();
	void buildPartB();
	Product getResult();
private:
	Product product;
};

void BuilderB::buildPartA()
{
	product.add("PartX");
}

void BuilderB::buildPartB()
{
	product.add("PartY");
}
 
Product BuilderB::getResult()
{
	return product;
}

class Director
{
public:
	void Construct(Builder *builder)
	{
		builder->buildPartA();
		builder->buildPartB();
	}
};


int main(int argc, char **argv)
{ 
	Director director;
	BuilderA *b1 = new BuilderA();
	BuilderB *b2 = new BuilderB();
	director.Construct(b1);
	Product p1 = b1->getResult();
	p1.show();

	director.Construct(b2);
	Product p2 = b2->getResult();
	p2.show();

	system("pause");
	return 0;
}

参考：《大话设计模式》