建造者模式（生成器模式）

建造者模式，就是将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。如果我们使用建造者模式，那么用户就只需指定需要建造的类型就可以得到它们，而不需要知道具体建造的过程和细节。

建造者模式结构图

image

建造者模式基本代码

#include <iostream>
#include <list>
#include <string>
using namespace std;

class Product {  // Product，产品类，由多个部件组成
private:
    list<string> parts;
public:
    void Add(string part) { parts.push_back(part); }  // 添加产品部件
    void show() {
        for (auto node = parts.begin(); node != parts.end(); node++) {
            cout << (*node) << "  ";
        }
        cout << endl;
    }
};

class Builder {
// Builder，抽象建造者类，是为创建一个Product对象的各个部件指定的抽象接口。确定产品由哪些部件组成，并声明一个得到产品建造后结果的方法
public:
    virtual void BuildPartA() = 0;
    virtual void BuildPartB() = 0; // 产品部件
    virtual Product* GetResult() = 0; // 得到产品
    virtual ~Builder() {}
};

// ConcreteBuilder1 & ConcreteBuilder2，具体建造者类，实现Builder接口，构造和装配各个部件
class ConcreteBuilder1 : public Builder {
private:
    Product* product;
public:
    ConcreteBuilder1() { product = new Product(); }
    void BuildPartA() { product->Add("ConcreteBuilder1 : PartA"); }
    void BuildPartB() { product->Add("ConcreteBuilder1 : PartB"); }
    Product* GetResult() { return product; }
};

class ConcreteBuilder2 : public Builder {
private:
    Product* product;
public:
    ConcreteBuilder2() { product = new Product(); }
    void BuildPartA() { product->Add("ConcreteBuilder2 : PartA"); }
    void BuildPartB() { product->Add("ConcreteBuilder2 : PartB"); }
    Product* GetResult() { return product; }
};

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

int main() { // 客户端实现代码
    Director* director = new Director();   // 指挥者，指挥如何构建一个Builder
    Builder* b1 = new ConcreteBuilder1();
    Builder* b2 = new ConcreteBuilder2();
    director->Construct(b1);               // 构建一个ConcreteBuilder1
    Product* p1 = b1->GetResult();         // 获取ConcreteBuilder1对应的产品
    p1->show();                            // ConcreteBuilder1 : PartA  ConcreteBuilder1 : PartB

    director->Construct(b2);
    Product* p2 = b2->GetResult();
    p2->show();                            // ConcreteBuilder2 : PartA  ConcreteBuilder2 : PartB 

    delete director;
    delete b1;
    delete b2;
    delete p1;
    delete p2;

}

使用场景

建造者模式主要用于创建一些复杂的对象，这些对象内部构建间的构造顺序通常是稳定的，但对象内部的构建通常面临着复杂的变化。其优点是使得建造代码与表示代码分离，由于建造者隐藏了该产品是如何组装的，所以若需要改变一个产品的内部表示，只需要再定义一个具体的建造者就可以了。
总的来说，建造者模式是在当创建复杂对象的算法应独立于该对象的组成部分以及它们的装配方式时适用的模式。