Buider模式

　　在软件设计中，有时候需要创建一个非常复杂的类对象，一次性的完成这个任务是非常艰巨的。但是，这个复杂的类对象通常可以分为几个较小的部分，这样，就可以分别创建这几个子对象然后组合为这个复杂类对象，这个过程相对来说比较稳定。但是，子对象的创建过程各不相同且可能产生变化。因此，根据OCP（Open-Closed Principle）原则，也需要对子对象的创建过程进行封装。

　　思路：定义一个抽象的创建者(Builder)，这个抽象类规定了所有的具体创建者应该具有的功能---即如何创建复杂对象的特定的部分(子对象)，创建过程由具体创建者实现。然后还需要定义一个指导者(Deirector)，它知道如何使用Builder来创建复杂的对象。这时候客户(Client)只需要给指导者指定一个具体的Builder，就能够使用Builder来创建复杂的类对象了。至于创建细节，是指导者和客户不需要关心的。

　　场景描述：一个人想买电脑，首先他得先确定哪个牌子的，然后选定牌子之后，他就要去找牌子的经销商(Director)，经销商监督这个牌子的厂家(Builder)一步步的完成电脑的装配工作的，具体的装配工作是这个人和经销商不需要关心的。

　　实现：

　　1、将变化的部分抽象成一个基类(Builder)和对应的接口函数。不会变化的时创建各个子对象的动作，变化的则是创建子对象的过程。因此抽象出来的基类是Builder，借口函数是BuilderPartA、BuilderPartB、BuilderPartC...

　　2、指导者如何使用创建者？将创建者基类的指针作为Director的成员，则指导者就能通过成员函数操作创建者了。

　　3、聚合，通过Director类中的contact函数，将各个子对象聚合起来，这里使用了多态，即基类的指针可以指向派生类对象。

　　具体实现：

/*Builder.h*/

#ifndef BUILDER_H_INCLUDED
#define BUILDER_H_INCLUDED

class Builder
{
    public:
        virtual ~Builder(){};
        Builder(){};

        //创建子对象的功能，声明为接口
        virtual void BuilderPartA() = 0;
        virtual void BuilderPartB() = 0;
};

class BuilderA:public Builder
{
    public:
        ~BuilderA(){};
        BuilderA(){};
        virtual void BuilderPartA()
        {
            std::cout<<"BuilderA build PartA"<<std::endl;
        }
        virtual void BuilderPartB()
        {
            std::cout<<"BuilderA build PartB"<<std::endl;
        }
};

class BuilderB:public Builder
{
    public:
        ~BuilderB(){};
        BuilderB(){};
        virtual void BuilderPartA()
        {
            std::cout<<"BuilderB build PartA"<<std::endl;
        }
        virtual void BuilderPartB()
        {
            std::cout<<"BuilderB build PartB"<<std::endl;
        }
};
#endif // BUILDER_H_INCLUDED

/*Director.h*/

#ifndef DIRECTOR_H_INCLUDED
#define DIRECTOR_H_INCLUDED

class Director
{
    public:
        ~Director(){};
        //Director(Builder* m_pBuilder1, Builder* m_pBuilder2 = NULL):pBuilder1(m_pBuilder1),pBuilder2(m_pBuilder2){};
        Director(Builder* m_pBuilder):pBuilder(m_pBuilder){};
        void contact();
    private:
        Builder* pBuilder;
        //Builder* pBuilder1;
        //Builder* pBuilder2;
};

void Director::contact()
{
    pBuilder->BuilderPartA();
    pBuilder->BuilderPartB();
    //pBuilder1->BuilderPartA();
    //pBuilder2->BuilderPartB();
}

#endif // DIRECTOR_H_INCLUDED


/*测试程序*/
#include<iostream>
#include"Builder.h"
#include"Director.h"
using namespace std;
int main()
{
    BuilderA* pBuilderA = new BuilderA();
    Director* pDirector = new Director(pBuilderA);
    pDirector->contact();
    BuilderB* pBuilderB = new BuilderB();
    Director* pDirector_1 = new Director(pBuilderB);
    pDirector_1->contact();
    //Director* pDirector_2 = new Director(pBuilderA, pBuilderB);
    //pDirector_2->contact();
    delete pBuilderA, pBuilderB;
    delete pDirector, pDirector_1;
    return 0;
}