建造者模式

设计模式

Builder模式也叫建造者模式或者生成器模式，是由GoF提出的23种设计模式中的一种。

Builder模式是一种对象创建型模式之一，用来隐藏复合对象的创建过程，它把复合对象的创建过程加以抽象，通过子类继承和重载的方式，动态地创建具有复合属性的对象。

对象的创建： Builder模式是为对象的创建而设计的模式-创建的是一个复合对象：被创建的对象为一个具有复合属性的复合对象-关注对象创建的各部分的创建过程：不同的工厂（这里指 builder生成器）对产品属性有不同的创建方法。

1) Builder：为创建产品各个部分，统一抽象接口。

2) ConcreteBuilder：具体的创建产品的各个部分，部分A，部分B，部分C.

3) Director：构造一个使用 Builder接口的对象。

4) Product：表示被构造的复杂对象。

Concrete Builder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类包括将这些部件装配成最终产品的接口。

工程队负责干活，设计师负责其逻辑。

适用情况：一个对象的构建比较复杂，将一个对象的构建和对象的表示进行分离。

代码实现

#include <iostream>

using namespace std;

//实际产品House（构建的方式比较复杂）
class House
{
public:
    void setDoor(string door)
    {
        m_door = door;
    }

    string getDoor()
    {
        return m_door;
    }

    void setWall(string Wall)
    {
        m_wall = Wall;
    }

    string getWall()
    {
        return m_wall;
    }

    void setWindow(string Window)
    {
        m_window = Window;
    }

    string getWindow()
    {
        return m_window;
    }

protected:
private:
    string m_door;
    string m_wall;
    string m_window;
};

//抽象的工程队（负责构造）
class Builder
{
public:
    virtual void makeDoor() = 0;
    virtual void makeWall() = 0;
    virtual void makeWindow() = 0;
    virtual House* getHouse() = 0;
protected:
private:
};

//公寓工程队
class FlatBuilder:public Builder
{
public:
    FlatBuilder()
    {
        m_house = new House();
    }
    virtual void makeDoor()
    {
        m_house->setDoor("Flat Door!");
    };
    virtual void makeWall()
    {
        m_house->setWall("Flat Wall!");
    }
    virtual void makeWindow()
    {
        m_house->setWindow("Flat Window!");
    }
    virtual House* getHouse()
    {
        return m_house;
    }
protected:
private:
    House* m_house;
};

//别墅工程队
class VillaBuilder : public Builder
{
public:
    VillaBuilder()
    {
        m_house = new House();
    }
    virtual void makeDoor()
    {
        m_house->setDoor("Villa Door!");
    };
    virtual void makeWall()
    {
        m_house->setWall("Villa Wall!");
    }
    virtual void makeWindow()
    {
        m_house->setWindow("Villa Window!");
    }
    virtual House* getHouse()
    {
        return m_house;
    }
protected:
private:
    House* m_house;
};

//设计师（负责指挥）
class Director
{
public:
    Director(Builder* builder)
    {
        m_builder = builder;
    };

    void Construct()
    {
        //规定构造的顺序
        m_builder->makeWall();
        m_builder->makeDoor();
        m_builder->makeWindow();
    }
protected:
private:
    Builder* m_builder;
};

int main()
{
    //具体的工程队
    VillaBuilder* villaBuilder = new VillaBuilder();
    //设计师
    Director* director = new Director(villaBuilder);
    //设计师指挥
    director->Construct();
    //产品从工程队拿出
    House* house = villaBuilder->getHouse();
    cout << house->getDoor() << " and " << house->getWall() << " and " << house->getWindow() << endl;

    delete house;
    delete villaBuilder;

    FlatBuilder* flatBuilder = new FlatBuilder();
    director = new Director(flatBuilder);
    director->Construct();
    house = flatBuilder->getHouse();
    cout << house->getDoor() << " and " << house->getWall() << " and " << house->getWindow() << endl;
    cout << "Hello world!" << endl;
    return 0;
}

输出：

Villa Door! and Villa Wall! and Villa Window!
Flat Door! and Flat Wall! and Flat Window!
Hello world!