建造者模式

【1】什么是建造者模式？

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

【2】建造者模式代码示例：

代码示例1：

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

class Person
{
public:
    virtual void createHead() = 0;
    virtual void createHand() = 0;
    virtual void createBody() = 0;
    virtual void createFoot() = 0;
};

class ThinPerson : public Person
{
    void createHead();
    void createHand();
    void createBody();
    void createFoot();
};

void ThinPerson::createHead()
{
    cout << "thin head" << endl;
}
void ThinPerson::createHand()
{
    cout << "thin hand" << endl;
}
void ThinPerson::createBody()
{
    cout << "thin body" << endl;
}
void ThinPerson::createFoot()
{
    cout << "thin foot" << endl;
}

class FatPerson : public Person
{
    void createHead();
    void createHand();
    void createBody();
    void createFoot();
};

void FatPerson::createHead()
{
    cout << "fat head" << endl;
}
void FatPerson::createHand()
{
    cout << "fat hand" << endl;
}
void FatPerson::createBody()
{
    cout << "fat body" << endl;
}
void FatPerson::createFoot()
{
    cout << "fat foot" << endl;
}

class Director
{
private:
    Person *m_pObj;

public:
    Director(Person *pTemp) : m_pObj(pTemp)
    {}

    void construct()
    {
        m_pObj->createHead();
        m_pObj->createHand();
        m_pObj->createBody();
        m_pObj->createFoot();
    }
};

// 客户端代码：
void main()
{
    Person *pFat = new FatPerson();
    Person *pThin = new ThinPerson();

    Director dctorFat(pFat);
    dctorFat.construct();

    Director dctorThin(pThin);
    dctorThin.construct();

    delete pFat;
    delete pThin;

    system("pause");
}
// run out
/*
fat head
fat hand
fat body
fat foot
thin head
thin hand
thin body
thin foot
请按任意键继续. . .
*/

代码示例2：

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

class Product
{
private:
    vector<string> m_vecProduct;

public:
    void add(string str)
    {
        m_vecProduct.push_back(str);
    }

    void show()
    {
        vector<string>::iterator iter = m_vecProduct.begin();
        while (iter != m_vecProduct.end())
        {
            cout << *iter << "  ";
            ++iter;
        }
        cout << endl;
    }
};

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

class ConcreteBuilder1 : public Builder
{
private:
    Product *m_pProduct;

public:
    ConcreteBuilder1()
    {
        m_pProduct = new Product();
    }
    virtual void builderA()
    {
        m_pProduct->add("one");
    }
    virtual void builderB()
    {
        m_pProduct->add("two");
    }
    virtual Product *getResult()
    {
        return m_pProduct;
    }
};


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

public:
    ConcreteBuilder2()
    {
        m_pProduct = new Product();
    }
    virtual void builderA()
    {
        m_pProduct->add("AA");
    }
    virtual void builderB()
    {
        m_pProduct->add("BB");
    }
    virtual Product *getResult()
    {
        return m_pProduct;
    }
};

class Director
{
private:
    Product *m_pProduct;

public:
    void construct(Builder *pBd)
    {
        pBd->builderA();
        pBd->builderB();
        m_pProduct = pBd->getResult();
    }
    Product *getResult()
    {
        return m_pProduct;
    }
};

void main()
{
    Director *pDirector = new Director();

    Builder *pBd1 = new ConcreteBuilder1();
    pDirector->construct(pBd1);
    Product *pbd1 = pDirector->getResult();
    pbd1->show();

    Builder *pBd2 = new ConcreteBuilder2();
    pDirector->construct(pBd2);
    Product *pbd2 = pDirector->getResult();
    pbd2->show();

    delete pBd1;
    delete pBd2;
    delete pDirector;

    system("pause");
}
// run out
/*
one  two
AA  BB
请按任意键继续. . .
*/

【3】建造者模式的优缺点

（1）优点

1、将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，使得我们能够更加精确的控制复杂对象的产生过程。

2、将产品的创建过程与产品本身分离开来，可以使用相同的创建过程来得到不同的产品。也就说细节依赖抽象。

3、每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象。

（2）缺点

1、建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。

2、如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大。

Good Good Study, Day Day Up.

顺序 选择 循环 总结