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

它主要是用于创建一些复杂的对象，这些对象内部构建间的建造顺序通常是稳定的，但对象内部的构造通常面临着复杂的变化。
建造者模式的好处就是使得建造代码与表示代码分离，由于建造者隐藏了该产品是如何组装的，所以若需要改变一个产品的内部表示，只需要再定义一个具体的建造者就可以了。

基本代码

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

using namespace std;

//Product类，产品类，由多个部件组成
class Product
{
private:
    vector<string> parts;

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

    void show()
    {
        cout << "\n产品  创建------";
        for (auto _i : parts)
            cout << _i;
    }
};

//Builder类---抽象建造者类，确定产品由两个部件PartA和PartB组成，并声明一个得到产品建造后结果的方法GetResult
class Builder
{
public:
    virtual void BuildPartA() = 0;
    virtual void BuildPartB() = 0;
    virtual Product* GetResult() = 0;
};

//具体建造者类
class ConcreteBuilder1 :public Builder
{
private:
    Product *product;

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

    void BuildPartA()
    {
        product->add("部件A");
    }

    void BuildPartB()
    {
        product->add("部件B");
    }

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

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

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

    void BuildPartA()
    {
        product->add("部件X");
    }

    void BuildPartB()
    {
        product->add("部件Y");
    }

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

//指挥类，用来控制建造过程，也用它来隔离用户与建造过程
class Director
{
public:
    void Construct(Builder* builder)
    {
        builder->BuildPartA();
        builder->BuildPartB();
    }
};

int main()
{
    Director* director = new Director();
    Builder* b1 = new ConcreteBuilder1();
    Builder* b2 = new ConcreteBuilder2();

    director->Construct(b1);
    Product* p1 = b1->GetResult();
    p1->show();

    director->Construct(b2);
    Product* p2 = b2->GetResult();
    p2->show();

    system("pause");
    return 0;
}