设计模式----创造者模式

创造者模式

把建造不同类型房子的过程与客户端调用分类，将一个复杂对象的构造与它的表示分离。创建者模式隐藏了复杂对象的创建过程，它把复杂对象的创建过程加以抽象，通过子类继承或者重载的方式，动态的创建具有复合属性的对象。创造者模中存在几个角色：

1. 建造者（Builder）：为创建一个产品对象的各个部件指定抽象接口。
2. 具体建造者（ConcreteBuilder）：实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示，并 提供一个检索产品的接口。
3. 指挥者（Director）：指挥并构造一个使用Builder接口的对象。
4. 产品（Product）：表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

    #include <iostream>
    #include <cstring>
    using namespace std;

    class House{
        public:
            void setFloor(string floor){
                this->floor = floor;
            }
            void setWall(string wall){
                this->wall = wall;
            }
            void setDoor(string door){
                this->door = door;
            }
            void show(){
                cout<<wall<<":"<<floor<<":"<<door<<endl;
            }
        private:
            string door;
            string wall;
            string floor;

    };

    class Builder{
        public:
            Builder(){
                this->house = new House();
            }
            virtual ~Builder(){}
            virtual void buildFloor()=0;
            virtual void buildWall()=0;
            virtual void buildDoor()=0;
            virtual House *getHouse(){
                return house;
            }
        protected:
            House *house;
    };

    class BungalowBuilder : public Builder{
        public:
            BungalowBuilder(){}
            virtual ~BungalowBuilder(){
                if(house!=NULL){
                    delete house;
                    house = NULL;
                }
            }
            virtual void buildFloor(){
                house->setFloor("Bungalow floor");
            }
            virtual void buildWall(){
                house->setWall("Bungalow wall");
            }
            virtual void buildDoor(){
                house->setDoor("Bungalow door");
            }
    };

    class thatchedCottageBuilder : public Builder{
        public:
            thatchedCottageBuilder(){}
            virtual ~thatchedCottageBuilder(){
                if(house!=NULL){
                    delete house;
                    house = NULL;
                }
            }
            virtual void buildFloor(){
                house->setFloor("thatchedCottage floor");
            }
            virtual void buildWall(){
                house->setWall("thatchedCottage wall");
            }
            virtual void buildDoor(){
                house->setDoor("thatchedCottage door");
            }
    };

    class Director{
        public:
            Director(Builder *builder){
                this->builder = builder;
            }
            void construct(){
                builder->buildWall();
                builder->buildFloor();
                builder->buildDoor();
            }
        private:
            Builder *builder;
    };

    int main()
    {
        Builder *builder = NULL;
        House *house = NULL;
        Director *director = NULL;

        builder = new BungalowBuilder();
        director = new Director(builder);
        director->construct();
        house = builder->getHouse();
        house->show();
        delete house;
        delete builder;
        delete director;
        return 0;
    }