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

考虑这样一个例子：

一个游戏里面有各种角色，这些角色是一个很复杂的对象，包含多个组成部分（皮肤、衣服等），要创建一个角色的工作会很麻烦：首先要创建好各个组成部分，然后再用这些组成部分来建造角色对象。

从这里我们可以看到：创建角色对象的步骤是一样的，只是构建各个组成部分的工作不一样，且可以扩展。

#include <iostream>
#include <string>

using namespace std;

class Product {
private :
    int id; // 假设为复杂对象
    string name; // 假设为复杂对象
public :
    Product() {
        id = 0;
        name = "";
    }
    void setId(int id) {
        this->id = id;
    }
    void setName(string name) {
        this->name = name;
    }
    int getId() {
        return this->id;
    }
    string getName() {
        return this->name;
    }
};

class Builder {
public :
    virtual void buildId() = 0;
    virtual void buildName() = 0;
    virtual Product * getResult() = 0;
};

class ConcreteBuilder : public Builder {
private :
    Product * product;
public :
    ConcreteBuilder() {
        product = new Product();
    }
    void buildId() {
        product->setId(1);
    }
    void buildName() {
        product->setName("Lucy");
    }
    Product * getResult() {
        return product;
    }
};

class Directer {
private :
    Builder * builder;
public :
    Directer(Builder * builder) {
        this->builder = builder;
    }
    Product * construct() {
        builder->buildId();
        builder->buildName();
        return builder->getResult(); 
    }
};

int main() {
    Builder * builder = new ConcreteBuilder();
    Directer * directer = new Directer(builder);
    Product * product = directer->construct();
    cout << "id : " << product->getId() << ", name : " << product->getName() << endl;
    
    delete product;
    delete directer;
    delete builder;

    return 0;
}

运行结果