创建者模式（builder）

一、        作用

创建一个复杂的对象，该对象有多个组成部分，一一创建完后再组装起来。书上说是创建与表示分离。

二、        模型图

 

 

三、        参与者

builder：一个，抽象的创建接口，封装了各个部分的创建方法。

concretebuilder：多个，具体负责产品的各个部分的创建。

director：一个，负责调用各个concretebuilder的创建方法，组装成产品。

product：一个，创建出来的复杂产品。

四、        操作流程

生成一个concretebuilder，传给director，由它来创建产品。

五、        比较

与抽象工厂模式相比，它仅能得到一个产品，而抽象工厂模式可以创建出一系列的产品。创建者模式创建产品要经过一个复杂的过程，而抽象工厂直接创建。

六、        C++实现

建造房子，它由墙，门，窗组成。

以下是C++代码实现：

 

#include <iostream>

 

class Wall

{

public:

    Wall(int color):m_color(color){}

private:

    int m_color;

};

class Door

{

public:

    Door(int color):m_color(color){}

private:

    int m_color;

};

class Win

{

public:

    Win(int color):m_color(color){}

private:

    int m_color;

};

class House

{

public:

    void AddWall(Wall *pWall){m_pWall = pWall;}

    void AddDoor(Door *pDoor){m_pDoor = pDoor;}

    void AddWin(Win *pWin){m_pWin = pWin;}

    Wall *GetWall(void){return m_pWall;}

    Door *GetDoor(void){return m_pDoor;}

    Win *GetWin(void){return m_pWin;}

private:

    Wall *m_pWall;

    Door *m_pDoor;

    Win *m_pWin;

};

 

class HouseBuilder

{

public:

    enum{REDHOUSE, BLUEHOUSE, WHITEHOUSE};

 

    virtual void BuildHouse(void){}

    virtual void BuildWall(void){}

    virtual void BuildDoor(void){}

    virtual void BuildWin(void){}

    virtual House *GetProduct(void){return NULL;}

    virtual void DestroyHouse(House *pHouse){}

};

class RedHouseBuilder: public HouseBuilder

{

public:

    RedHouseBuilder(void){m_pHouse = NULL;}

 

    void BuildHouse(void)

    {

        m_pHouse = new House;

    }

    void BuildWall(void)

    {

        if (m_pHouse != NULL)

        {

            Wall *pWall = new Wall(REDHOUSE);

            m_pHouse->AddWall(pWall);

        }

    }

    void BuildDoor(void)

    {

        if (m_pHouse != NULL)

        {

            Door *pDoor = new Door(REDHOUSE);

            m_pHouse->AddDoor(pDoor);

        }

    }

    void BuildWin(void)

    {

        if (m_pHouse != NULL)

        {

            Win *pWin = new Win(REDHOUSE);

            m_pHouse->AddWin(pWin);

        }

    }

    House *GetProduct(void)

    {

        return m_pHouse;

    }

    void DestroyHouse(House *pHouse)

    {

        if (pHouse == NULL)

            return;

 

        Wall *pWall = pHouse->GetWall();

        delete pWall;

        Door *pDoor = pHouse->GetDoor();

        delete pDoor;

        Win *pWin = pHouse->GetWin();

        delete pWin;

 

        delete pHouse;

    }

 

private:

    House *m_pHouse;

};

 

class HouseDirector

{

public:

    HouseDirector(HouseBuilder *pBuilder){m_pBuilder = pBuilder;}

 

    void construct(void)

    {

        if (m_pBuilder == NULL)

            return;

        m_pBuilder->BuildHouse();

        m_pBuilder->BuildWall();

        m_pBuilder->BuildDoor();

        m_pBuilder->BuildWin();

    }

 

private:

    HouseBuilder *m_pBuilder;

};

 

 

int main(int argc, char **argv)

{

    House *pRedHouse;

 

    RedHouseBuilder Builder;

    HouseDirector Director(&Builder);

    Director.construct();

 

    pRedHouse = Builder.GetProduct();

    Builder.DestroyHouse(pRedHouse);

 

    return 0;

}