建造者模式，又称为builder模式。

定义：

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

使用场景：

当一个类的构造函数参数个数超过4个，而且这些参数有些是可选的参数，考虑使用构造者模式。

使用建造者模式有什么好处：

建造者模式的好处就是使得建造代码与表示代码分离，由于建造者隐藏了 该产品是如何组装的，所以若需要改变一个产品的内部表示，只需要再定义一个具体的建造者就可以了。

代码实现：

#include#include#includeusing namespace std;

class Product{
private:
    vectorparts;

public:
    void Add(string part){
        parts.push_back(part);
    }

    void Show(){
        cout << "product building------------" << endl;
        vector::iterator it;
        for (it = parts.begin(); it != parts.end(); it++)
        {
            cout << *it << endl;
        }
    }
};

class Builder
{
public:
    virtual void BuildPartA() = 0;
    virtual void BuildPartB() = 0;
    virtual Product* GetResult() = 0;
};

class ConcreteBulider1:public Builder
{
private:
    Product* product;

public:
    ConcreteBulider1(){
        product = new Product();
    }

    ~ConcreteBulider1(){
        delete product;
    }

    void BuildPartA(){
        product->Add("part A");
    }

    void BuildPartB(){
        product->Add("part B");
    }

    Product* GetResult(){
        return product;
    }
};

class ConcreteBulider2 :public Builder
{
private:
    Product* product;

public:
    ConcreteBulider2(){
        product = new Product();
    }

    ~ConcreteBulider2(){
        delete product;
    }

    void BuildPartA(){
        product->Add("part X");
    }

    void BuildPartB(){
        product->Add("part Y");
    }

    Product* GetResult(){
        return product;
    }
};

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

//Client，客户不知道具体的建造过程。
int main()
{
    Director* director = new Director();

    Builder* builder1 = new ConcreteBulider1();
    Builder* builder2 = new ConcreteBulider2();

    cout << "指挥者用ConcreteBuilder1的方法建造产品：" << endl;
    director->Construct(builder1);
    Product* p1 = builder1->GetResult();
    p1->Show();
    cout << endl;

    cout << "指挥者用ConcreteBuilder2的方法建造产品：" << endl;
    director->Construct(builder2);
    Product* p2 = builder2->GetResult();
    p2->Show();
    cout << endl;

    delete director;
    delete builder1;
    delete builder2;

    system("pause");

    return 0;
}

代码说明：

（1）Builder：是为创建一个Product对象的各个部件指定的抽象接口。

（2）ConcreteBuilder：是具体创建者，实现Builder接口，构造和装配各个部件。

（3）Product：具体的产品角色。

（4）Director：指挥者，他是构建一个使用Builder接口的对象。

运行结果：

指挥者用ConcreteBuilder1的方法建造产品： product building------------ part A part B

指挥者用ConcreteBuilder2的方法建造产品： product building------------ part X part Y