老肖的脑残实现如下：

class Product
{

};

class Builder
{
public:
    virtual Product* BuildPart();
};

class ConcreteBuilder1 : Builder
{
public:
    Product* BuildPart() { return new Product(); }
    void GetResult();
};

class ConcreteBuilder2 : Builder
{
public:
    Product* BuildPart() { return new Product(); }
    void GetResult();
};

class Director
{
private:
    Builder** builders;
public:
    void Construct()
    {
        builders = new Builder*[2];
        builders[0] = new ConcreteBuilder1();
        builders[1] = new ConcreteBuilder2();

        for(int i=0;i<2;i++)
        {
            builders[i]->BuildPart();
        }
    }
};

很显然，我觉得书上的类图和书上的代码实现有出入，既然是Builder对象的聚合，那么为何只作为Director的构造函数的参数进行传入。如果完全按照类图的实现，就像上面的代码那样脑残，在一个循环创建后，根本无法保留创建后的状态，难道类图中隐藏了Dirctor对于Product的聚合？抑或是根据每个Builder对象进行操作，但每个Builder对象对于Product只是个弱引用而已，不解！

--------------------过了一天，我是分割线-------------------------------------------------------------

书上的图，很令我迷茫，但是在今天和同学K讨论后又似乎有那么点开窍。

首先，关于聚合的概念需要进一步更新，聚合意味着一个对象拥有另一个对象或对另一个对象负责。并且聚合对象和其拥有者具有相同的生命周期。于是乎写出如下代码：

老肖的非脑残实现如下：

class Product
{

};

class Builder
{
public:
    virtual void BuildPart();
    virtual Product* GetResult() { return 0; }
};

class ConcreteBuilder : Builder
{
private:
    Product* currentProduct;
public:
    void BuildPart() { currentProduct = new Product(); }
    Product* GetResult() { return currentProduct; }
};

class Director
{
private:
    Builder* builders;
public:
    Director(Builder* outBuilder)
    {
        builders = outBuilder;
    }
    void Construct()
    {
        builders->BuildPart();
    }
};

适用性：

当创建复杂对象的算法应该独立于该对象的组成部分以及他们的装配方式时。

当构造过程必须允许被构造的对象有不同的表示时。