Builder模式和Factory模式的區別是：Builder模式是分步創建對象。在此模型中有個director類，通過它來把切片stream傳遞給builder，通過切片來創建對象。此中模式把部件組合成完整的產品和部件的實現分開，從而實現通過共同的接口的不同實現創建產品。
#include <iostream>
#include <string>
#include <vector>
#include <cstddef>
#include ".../purge.h"
using std::size_t;

class BicyclePart{
public:
   enum BPart{FRAME,WHEEL,SEAT,DERAILLEUR,HANDLERBAR,SPROCKET,RACK,SHOCK,NPARTS};
private:
   BPart id;
   static std::string names[NPARTS];
public:
   BicyclePart(BPart bp) {id=bp;}
   friend std::ostream& operator<<(std::ostream& os,const BicyclePart& pb){
      return os<<bp.names[bp.id];}
};

class Bicycle{
   std::vector<BicyclePart*> parts;
public:
   ~Bicycle() {pruge(parts);}
   void addParts(BicyclePart* bp){parts.push_back(bp);}
   friend std::ostream& operator<<(std::ostream& os,const Bicycle& b){
      os<<"{";
      for(size_t i= 0; i < b.parts.size();++i)
         os<<*b.parts[i]<<' ';
      return os <<"}";}
};

class BicycleBuilder{
protected:
   Bicycle* product;
public:
   BicycleBuilder(){product = 0;}
   void CreateProcuct(){product = new Bicycle;}
   virtual void buildFrame()=0;
   virtual void buildWheel()=0;
   virtual void buildSeat()=0;
   virtual void buildDerailleur()=0;
   virtual void buildHandlebar()=0;
   virtual void buildSprocket()=0;
   virtual void buildRack()=0;
   virtual void buildShocK()=0;
   virtual std::string getBikeName() const =0;
   Bicycle* getProduct(){
      Bicycle* temp= product;
      product = 0; //Relinquish product
      return temp;}
};

class  MountainBikeBuilder:public BicycleBuilder{
public:
   void buildFrame();
   void buildWheel();
   void buildSeat();
   void buildDerailleur();
   void buildHandlebar();
   void buildSprocket();
   void buildRack();
   void buildShocK();
   std::string getBikeName() const {return "MountainBike"}
};

class  TouringBikeBuilder:public BicycleBuilder{
public:
   void buildFrame();
   void buildWheel();
   void buildSeat();
   void buildDerailleur();
   void buildHandlebar();
   void buildSprocket();
   void buildRack();
   void buildShocK();
   std::string getBikeName() const {return "TouringBike"}
};

class RacingBickBuilder:public BicycleBuilder{
public:
   void buildFrame();
   void buildWheel();
   void buildSeat();
   void buildDerailleur();
   void buildHandlebar();
   void buildSprocket();
   void buildRack();
   void buildShock();
   std::string getBickName()const {return "RacingBike";}
};

class BicycleTechnician{
   BicycleBuilder* builder;
public:
   BicycleTechnician(){builder=0;}
   void setBuilder(BicycleBuiler* b) {builder=b;}
   void construct();
};

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
std::string BicyclePart::names[NPARTS] ={"Frame","Wheel","Seat","Derailleur","Handlebar","Sprocket","Rack","Shock"};

//MountainBikeBuilder implementation
void MountainBikeBuilder::buildFrame(){product->addpart(new BicyclePart(Bicycle::FRAME));}
void MountainBikeBuilder::buildWheel(){product->addpart(new BicyclePart(Bicycle::WHEEL));}
void MountainBikeBuilder::buildSeat(){product->addpart(new BicyclePart(Bicycle::SEAT));}
void MountainBikeBuilder::buildDerailleur(){product->addpart(new BicyclePart(Bicycle::DERAILLEUR));}
void MountainBikeBuilder::buildHandlebar(){product->addpart(new BicyclePart(Bicycle::HANDLEBAR));}
void MountainBikeBuilder::buildSprocket(){product->addpart(new BicyclePart(Bicycle::SPROCKET));}
void MountainBikeBuilder::buildRack(){}
void MountainBikeBuilder::buildShock(){product->addpart(new BicyclePart(Bicycle::SHOCK));}
   
//TouringBikeBuilder implementation
void TouringBikeBllider::buildFrame(){product->addpart(new BicyclePart(Bicycle::FRAME));}
void TouringBikeBuilder::buildWheel(){product->addpart(new BicyclePart(Bicycle::WHEEL));}
void TouringBikeBuilder::buildSeat(){product->addpart(new BicyclePart(Bicycle::SEAT));}
void TouringBikeBuilder::buildDerailleur(){product->addpart(new BicyclePart(Bicycle::DERAILLEUR}
void TouringBikeBuilder::buildHandlebar(){product->addpart(new BicyclePart(Bicycle::HANDLEBAR));}
void TouringBikeBuilder::buildSprocket(){product->addpart(new BicyclePart(Bicycle::SPROCKET));}
void TouringBikeBuilder::buildRack(){product->addpart(new BicyclePart(Bicycle::RACK));}
void TouringBikeBuilder::buildShock(){}

//RacingBikeBulider implementation
void RacingBikeBuilder::buildFrame(){product->addpart(new BicyclePart(Bicycle::FRAME));}
void RacingBikeBuilder::buildWheel(){product->addpart(new BicyclePart(Bicycle::WHEEL));}
void RacingBikeBuilder::buildSeat(){product->addpart(new BicyclePart(Bicycle::SEAT));}
void RacingBikeBuilder::buildDerailleur(){}
void RacingBikeBuilder::buildHandlebar(){product->addpart(new BicyclePart(Bicycle::HANDLEBAR));}
void RacingBikeBuilder::buildSprocket(){product->addpart(new BicyclePart(Bicycle::SPROCKET));}
void RacingBikeBuilder::buildRack(){}
void RacingBikeBuilder::buildShock(){}

//BicycleTechnician implementation
void BicycleTechnician::construct(){
   assert(builder);
   builder->createProduct();
   builder->buildFrame();
   builder->buildWheel();
   builder->buildSeat();
   builder->buildDerailleur();
   builder->buildHandlbar();
   builder->buildSprocket();
   builder->buildRack();
   builder->buildShock();
};

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include <cstddef>
#include <iostream>
#include <map>
#include <vector>
#inculde "../purge.h"
using namespace std;

//constructs a bike via a concrete builder
Bicycle* buildMeBike(BicycleTechnician& t,BicycleBuilder* builder){
   t.setBuilder(builder);
   t.construct();
   Bicycle* b = builder->getProduct();
   cout<<"Build a"<<builder->getBikeName()<<endl;
   return b;
}

int main(){
   //Create an order for some bicycle
   map<string,size_t> order;
   order["mountain"] = 2;
   order["toruing"] = 1;
   order["racing"] = 3;

   //build bikes
   vector<Bicycle*> bikes;
   BicycleBuilder* m = new MountainBikeBuilder;
   BicycleBuilder* t = new TouringBikeBuilder;
   BicycleBuilder* r = new RacingBikeBuilder;
   BicycleTechnician tech;
   map<string,size_t> ::iterator it = order.begin();
   while(it != order.end()){
      BicycleBuilder* builder;
      if(it->first == "Mountain")
         builder = m;
      else if(it->first == "touring")
         builder = t;
      else if(it->first == "racing")
         builder = r;
      for(size_t i=0; i < it->second; ++i)
         bikes.push_back(builderMeABike(tech,builder));
      ++ it;
   }
   delete m;
   delete t;
   delete r;
   
   //Display inventory
   for(size_t i = 0; i < bikes.size(); ++i)
      cout<<"Bicycle" <<*bikes[i] <<endl;
   pruge(bikes);
}