如果你需要将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示的意图时，我们需要应用于一个设计模式，‘建造者（Builder）模式’，又叫生成器模式。建造者模式可以将一个产品的内部表象与产品的生成过程分割开来，从而可以使一个建造过程生成具有不同的内部表象的产品对象。如果我们用了建造者模式，那么用户就只需指定需要建造的类型就可以得到它们，而具体建造的过程和细节就不需知道了。”

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

UML

测试代码：

#include <iostream>
#include <list>
using namespace std;
 
class Product{
private:
    list<string> parts;
public:
    void add(string part){
        parts.push_back(part);
    }
    void show(){
        list<string>::iterator it;
        for(it = parts.begin();it != parts.end();it++){
            cout << "parts:" << *it << " ";
        }
        cout << endl << endl;
 
    }
};
 
class Builder
{
public:
    virtual void BuildPartA() = 0;
    virtual void BuildPartB() = 0;
    virtual Product *GetProduct() = 0;
};
 
class ConcreteBuilder1:public Builder
{
private:
    Product *product = nullptr;
public:
    ConcreteBuilder1(){
        product = new Product();
    }
    virtual void BuildPartA(){
        product->add("A");
 
    }
    virtual void BuildPartB(){
        product->add("B");
    }
    virtual Product *GetProduct(){
        return product;
    }
};
 
class ConcreteBuilder2:public Builder
{
private:
    Product *product = nullptr;
public:
    ConcreteBuilder2(){
        product = new Product();
    }
    virtual void BuildPartA(){
        product->add("X");
 
    }
    virtual void BuildPartB(){
        product->add("Y");
    }
    virtual Product *GetProduct(){
        return product;
    }
};
class Director{
public:
    void Construct(Builder *b){
        b->BuildPartA();
        b->BuildPartB();
    }
};
 
int main(void)
{
    Director d;
    cout << "产品1" << endl;
    Builder *b1 = new ConcreteBuilder1();
    d.Construct(b1);
    b1->GetProduct()->show();
 
    cout << "产品2" << endl;
    Builder *b2 = new ConcreteBuilder2();
    d.Construct(b2);
    b2->GetProduct()->show();
 
    return 0;
}

运行结果：

产品1
parts:A parts:B 

产品2
parts:X parts:Y