如果一个对象的构建比较复杂，将一个对象的构建和对象的表示进行分离，使得同样的构建过程可以创建不同的表示，那么比较适合采用建造者模式。 

builer： 为创建产品的各个部分，统一抽象接口
Abuilder：具体的建造着类，创建该产品的各个部分，部分A、部分B、部分C director：构造一个使用builer接口的对象
product：表示被构造的复杂对象

一个对象的构建比较复杂，将一个对象的构建和对象的表示进行分离，使得同样的构建过程可以创建不同的表示 

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


class house{
public:
     void setDoor(string str){
       m_door =str;
       cout<<str<<endl;
    }

    void setWindow(string str){
         m_wall=str;
         cout<<str<<endl;
    }

    void setWall(string str){
         m_window=str;
         cout<<str<<endl;
    }

private:
    string m_door;
    string m_wall;
    string m_window;

};

class builder{
public:
    virtual void buildWall() = 0;
    virtual void buildWindow() = 0;
    virtual void buildDoor() = 0;
    virtual house* getHouse() = 0;
};

class director{
public:
    director(builder* pBuilder){
        m_pBuilder = pBuilder;
    }

    void construct(){
        m_pBuilder->buildWall();
        m_pBuilder->buildDoor();
        m_pBuilder->buildWindow();
    }

private:
    builder* m_pBuilder;
};


//公寓工程队
class FaltBuilder: public builder{
   public:
    FaltBuilder(){
        m_pHouse = new house();
    }
    void buildWall(){
        m_pHouse->setWall("建造公寓墙");
    }

    void buildWindow(){
        m_pHouse->setWindow("建造公寓窗");
    }

    void buildDoor() {
        m_pHouse->setDoor("建造公寓门");
    }

    house* getHouse(){
        return m_pHouse;
    }

   private:
    house* m_pHouse;
};


//别墅工程队
class villaBuilder: public builder{
   public:

    villaBuilder(){
        m_pHouse = new house();
    }

    void buildWall(){
        m_pHouse->setWall("建造别墅墙");
    }

    void buildWindow(){
        m_pHouse->setWindow("建造别墅窗");
    }

    void buildDoor() {
        m_pHouse->setDoor("建造别墅门");
    }

    house* getHouse(){
        cout<<"返回建造好的房子"<<endl;
        return m_pHouse;
    }

   private:
    house* m_pHouse;
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    builder* pbuilder = NULL;

    //建造别墅
    pbuilder = new villaBuilder();

    //同样的方法建造平房
    //pbuilder = new FaltBuilder();

    director * pdirector = new director(pbuilder);

    //造房子
    pdirector->construct();

    //获得房子
    pbuilder->getHouse();

    return a.exec();
}

 

使用场景：
相同的方法，不同的执行顺序，产生不同的事件结果时，采用建造者模式。
多个零部件，都可以装配到一个对象中，但是产生的运行效果又不相同时，则可以使用该模式。
产品类非常复杂，或者产品中的调用顺序不同产生了不同的效能，这个时候建造者模式非常适合。