builder pattern--建造者模式

buildre pattern称建造者模式

Builder设计模式，提供一种封装机制来隔离出构成复杂对象的各个子对象的变化，从而保持系统中的相对稳定的将这些子对象组合在一起的算法不随着需求的改变而改变。

 

Separate the construction of a complex object from its representation so that the same construction process can create different representations.  - GoF

建造者（Builder）：

给出一个抽象接口，以规范产品对象的各个组成成分的建造。一般而言，此接口独立于应用程序的商业逻辑。模式中直接创建产品对象的是具体建造者（ConcreteBuilder）角色。具体建造者类必须实现这个接口所要求的方法：一个是建造方法，另一个是结果返还方法。

 

具体建造者（Concrete Builder）：

担任这个角色的是于应用程序紧密相关的类，它们在应用程序调用下创建产品实例。这个角色主要完成的任务包括：

- 实现Builder角色提供的接口，一步一步完成创建产品实例的过程。

- 在建造过程完成后，提供产品的实例。

 

指导者（Director）：

担任这个角色的类调用具体建造者角色以创建产品对象。导演者并没有产品类的具体知识，真正拥有产品类的具体知识的是具体建造者对象。

 

产品（Product）：

产品便是需要建造的复杂对象。

实例：

例如所有的汽车的构建其实是有轮子(Michelin--米其林,Bridgestone--普利司通)、发动机(China,America)、外壳(Normal,Special)三大部分组成。

//------------------------三个组成该汽车的基类-----------------------------
//abstract part
//其实属性可以有很多，这里就不一一列出来。
class wheel
{
    public:
        wheel(std::string n,int l)
        :name(n),loadCapacity(l)
        {}
        virtual std::string getName( )=0;
        virtual int getLG( )=0;
        ...
    protected:
        std::string name;
        int loadCapacity;         //负载能力
        ...
};

class engine
{
    public:
        engine(std::string n,int s)
        :name(n),speed(s)
        {}
        virtual std::string getName( )=0;
        virtual int getSpeed( )=0;
        ...
    protected:
        std::string name;
        int speed ;                   //转速
        ...
};

class shell
{
    public:
        shell(std::string n,std::string c)
        :name(n),color(c)
        {}
        virtual std::string getName( )=0;
        virtual std::string getColor( )=0;
        ...
    protected:
        std::string name;
        std::string color        //颜色
        ...
};

//------------------------继承上面基类wheel 的轮胎类-----------------------------
//concerte part  
//米其林轮胎
class wheelMichelin:public wheel
{
    public:
        wheelMichelin(std::string n,int l)
        :wheel(n,l)
        {}
       std::string getName( );
       int getLG( );
};
std::string wheelMichelin::getName( )
{
    return name;
}
int wheelMichelin::getLG( )
{
    return loadCapacity;
}

//普利司通轮胎
class wheelBridgestone:public wheel
{
    public:
        wheelBridgestone(std::string n,int l)
        :wheel(n,l)
        {}
       std::string getName( );
       int getLG( );
};
std::string wheelBridgestone::getName( )
{
    return name;
}
int wheelBridgestone::getLG( )
{
    return loadCapacity;
}
//--------------------------继承上面基类engine的引擎类-----------------------------------------
//中国制造
class engineChina:public engine
{
    public:
        engineChina(std::string n,int s)
        :engine(n,s)
        {}
        std::string getName( );
        int getSpeed( );
};
std::string engineChina::getName( )
{
    return name;
}
int engineChina::getSpeed( )
{
    return speed;
}

//美国制造
class engineAmerica:public engine
{
    public:
        engineAmerica(std::string n,int s)
        :engine(n,s)
        {}
        std::string getName( );
        int getSpeed( );
};
std::string engineAmerica::getName( )
{
    return name;
}
int engineAmerica::getSpeed( )
{
    return speed;
}
//----------------------------继承基类shell的外壳类--------------------------------------
//普通
class shellNormal:public shell
{
    public:
        shellNormal(std::string n,std::string c)
        :shell(n,c)
        {}
        std::string getName( );
        int getColor( );
};
std::string shellNormal::getName( )
{
    return name;
}
std::string shellNormal::getColor( )
{
    return color;
}

class shellSpecial:public shell
{
    public:
        shellSpecial(std::string n,std::string c)
        :name(n),color(c):shell(n,c)
        {}
        std::string getName( );
        int getColor( );
};
std::string shellSpecial::getName( )
{
    return name;
}
std::string shellSpecial::getColor( )
{
    return color;
}
//---------------------------产品的基类即车-------------------------------
//abstract product
//车由wheel,engine,shell组成
class car
{
     public:
        virtual void setwh(std::auto_ptr<wheel> w)=0;
        virtual void seten(std::auto_ptr<engine> e)=0;
        virutal void setsh(std::auto_ptr<shell> s)=0;
        virtual std::auto_ptr<wheel> getwh( )=0;
        virtual std::auto_ptr<engine> geten( )=0;
        virtual std::auto_ptr<shell> getsh( )=0;
    protected:
         std::auto_ptr<wheel>    pw;     //轮子
         std::auto_ptr<engine>  pe;     //发动机
         std::auto_ptr<shell>      ps;     //外壳    
};
//------------------------------继承上面基类的车类---------------------------
//concerte product
class AudiCar:public car
{
        public:     
            void setwh(std::auto_ptr<wheel> w);
            void seten(std::auto_ptr<engine> e);
            void setsh(std::auto_ptr<shell> s);
            std::auto_ptr<wheel> getwh( );
            std::auto_ptr<engine> geten( );
            std::auto_ptr<shell> getsh( );
};
void AudiCar::setwh(std::auto_ptr<wheel> w)
{
    pw=w;
}
void AudiCar::seten(std::auto_ptr<engine> e)
{
    pe=e;
}
void AudiCar::setps(std::auto_ptr<shell> s)
{
    ps=s;
}
wheel*  AudiCar::getwh( )
{
    if(!pw.get( ))
    {
        throw std::invalid_argument("Error: pointer is null!!");
    }
    return wh.get( );
}
engine*  AudiCar::geten( )
{
    if(!pe.get( ))
    {
        throw std::invalid_argument("Error: pointer is null!!");
    }
    return pe.get( );
}
shell* AudiCar::getsh( )
{
    if(!ps.get( ))
    {
        throw std::invalid_argument("Error:pointer is null!!");
    }
    return ps.get( );
}

//奔驰
class BenzCar:public car
{
        public:
            void setwh(std::auto_ptr<wheel> w);
            void seten(std::auto_ptr<engine> e);
            void setsh(std::auto_ptr<shell> s);
            std::auto_ptr<wheel> getwh( );
            std::auto_ptr<engine> geten( );
            std::auto_ptr<shell> getsh( );
};
BenzCar::setwh(std::auto_ptr<wheel> w)
{
    pw=w;
}
BenzCar::seten(std::auto_ptr<engine> e)
{
    pe=e;
}
BenzCar::setsh(std::auto_ptr<shell> s)
{
    ps=s;
}
wheel*  BenzCar::getwh( )
{
    if(!pw.get( ))
    {
        throw std::invalid_argument("Error: pointer is null!!");
    }
    return pw.get( );
}
engine*  BenzCar::geten( )
{
    if(!pe.get( ))
    {
        throw std::invalid_argument("Error: pointer is null!!");
    }
    return pe.get( );
}
shell*  BenzCar::getsh( )
{
    if(!ps.get( ))
    {
        throw std::invalid_argument("Error:pointer is null!!");
    }
    return  ps.get( );
}
------------------------------------------------------------------
class builder
{
    public:
        virtual void buildWheel( )=0;
        virtual void buildEngine( )=0;
        virtual void buildShell( )=0;
        virtual car*  getCar( )=0;
};

class BenzBuilder:public builder
{
    public:
        BenzBuilder()
        :c(new BenzCar())
        {}
        void buildWheel();
        void buildEngine();
        void buildShell();
        car* getCar( );
    private:
        std::auto_ptr<car> c;
};

//生产奔驰的轮胎
void BenzBuilder::buildWheel( )
{
    //采用米其林轮胎
    std::auto_ptr<wheel> w(new wheelMichelin("Michelin",270 ));
    c->setwh(); 
}

//生产奔驰的引擎
void BenzBuilder::buildEngine( )
{
    //美国产引擎
    std::auto_ptr<engine> w(new engineAmercia("Amercia",300));
    c->seten();
}

//生产奔驰的外壳
void BenzBuilder::buildShell( )
{
    std::auto_ptr<sheel> w(new shellNormol("Normal","Red"));
    c->setsh();
}

std::auto_ptr<car> BenzBuilder::getCar( )
{
    return c.get( );
}

class AudiBuilder:public builder
{
   public:
        AudiBuilder( )
        :c(new AudiCar( ))
        {}
        void buildWheel( );
        void buildEngine( );
        void buildShell( );
        std::auto_ptr<car> getCar( );
    private:
        std::auto_ptr<car> c;
};

void AudiBuilder::buildWheel( )
{
     //采用高通
    std::auto_ptr<wheel> w(new wheelBridgestone("Bridgestone",250));
    c->setwh( );
}

void AudiBuilder::buildEngine( )
{
    //中国产引擎
    std::auto_ptr<engine> w(new EngineChina("China",320));
    c->seten( );
}

void AudiBuilder::buildShell( )
{
    std::auto_ptr<shell> w(new ShellSpecial("Special","white"));
    c-setsh(w);
}

car* AudiBuilder::getCar( )
{
    return c.get( );
}
//------------------------------组装汽车--------------------------------------------
class director
{
    public:
        static std::auto_ptr<car> construct(std::auto_ptr<builder> b);
}
std::auto_ptr<car> director::construct( std::auto_ptr<builder> b)
{
    b->buildWheel( );
    b->buildEngine( );
    b->buildShell( );
    return b->getCar( );
}

int main(int argc,char **argv)
{
    std::auto_ptr<builder> b(new BenzBuilder( );
    std::auto_ptr<car> c=director::construct(b);
    std::cout<<"The BenzCar's wheel is "<<c->getwh( )->getName( )<<std::endl;
    std::cout<<"Its  loadCapacity  is  "<<c->getwh( )->getLG( )<<std::endl;
    std::cout<<"The BenzCar's engine is made in "<<c->geten()->getName( )<<std::endl; 
    std::cout<<"Its speed is "<<c->geten()->getSpeed()<<std::endl;
    std::cout<<"The BenzCar's shell is "<<c->getsh()->getName( )<<std::endl;
    std::cout<<"Its color is "<<c->getsh()->getColor()<<std::endl;
    std::auto_ptr<builder> b2(new AudiBuilder( );
    std::auto_ptr<car> c2=director::construct(b2);
    std::cout<<"The AudiCar's wheel is "<<c2->getwh( )->getName( )<<std::endl;
    std::cout<<"Its  loadCapacity  is  "<<c2->getwh( )->getLG( )<<std::endl;
    std::cout<<"The AudiCar's engine is made in "<<c2->geten()->getName( )<<std::endl; 
    std::cout<<"Its speed is "<<c2->geten()->getSpeed()<<std::endl;
    std::cout<<"The AudiCar's shell is "<<c2->getsh()->getName( )<<std::endl;
    std::cout<<"Its color is "<<c2->getsh()->getColor()<<std::endl;
    return 0;
}

结果