设计模式-创建-Builder(建造者)模式

当一个对象的构造过程比较复杂、需要分成若干步骤来完成时，可以考虑使用建造者模式（Builder）来处理。

建造者模式的核心思想是：把一个复杂对象的构建过程与它的最终表示分离，使得同样的构建流程可以生成不同的表示形式。

通常的做法是把复杂对象的构建拆成若干个部分，例如 BuildPartA、BuildPartB、BuildPartC 等等，由不同的角色分别负责接口定义、具体实现和装配流程。

角色划分

• Builder：规定构建过程中涉及的一组接口。
• ConCreateBuilder：Builder 的具体实现，负责真正完成每个部件的构建。
• Director：负责具体的装配调用，按既定顺序驱动 Builder 完成构建。

版本 1

第一个版本里，Director 在构造函数中持有一个 Builder 引用，由 Director 自身决定各个部件的装配顺序。

class Procudt
                {
                public:
                	void initPartA(){}
                	void initPartB(){}
                	void Print(){ cout << __FUNCTION__ << endl; }
                };
                
                
                
                
                class Builder
                {
                public:
                	virtual void BuildPartA() = 0;
                	virtual void BuildPartB() = 0;
                	virtual Procudt* GetProduct() = 0;
                
                };
                
                class ConCreateBuilder :public Builder
                {
                	Procudt *product;
                
                public:
                	virtual void BuildPartA()override
                	{
                		cout << __FUNCTION__ << endl;
                		product->initPartA();
                	}
                	virtual void BuildPartB()override
                	{
                		cout << __FUNCTION__ << endl;
                		product->initPartB();
                	}
                
                	Procudt * GetProduct()override
                	{
                		return product;
                	}
                };
                
                
                
                class Director
                {
                public:
                	Director(Builder *builder)
                	{
                		_builder = builder;
                	}
                	void Construct()
                	{
                		_builder->BuildPartA();
                		_builder->BuildPartB();
                	}
                	Builder* _builder;
                
                };
                
                int main(int argc, char *argv[])
                {
                	ConCreateBuilder* builder = new ConCreateBuilder;
                
                
                	Director* director = new Director(builder);
                
                	director->Construct();
                	builder->GetProduct()->Print();
                
                
                	system("pause");
                	return 0;
                }

版本 2

第二个版本把 Builder 的传入时机从 Director 的构造函数挪到了 Construct 方法的参数上，Director 本身不再持有 Builder，只承担"组装"这个纯粹的动作。

class Director
                {
                public:
                
                	Builder* Construct(Builder *_builder)
                	{
                		_builder->BuildPartA();
                		_builder->BuildPartB();
                		return _builder;
                	}
                
                };
                
                int main(int argc, char *argv[])
                {
                	ConCreateBuilder* builder = ;
                
                
                	Director* director = new Director();
                
                	Builder *builder = director->Construct(new ConCreateBuilder);
                	builder->GetProduct()->Print();
                
                
                	system("pause");
                	return 0;
                }
                //Director 只是一个 组装