泛化Factory

class Shape
{
 public :
 virtual void Draw()const=0;
 virtual void Rotate(double angle) =0;
 virtual void Zoom(double zoomFactor)=0;
}
class Drawing
{
 public:
 void Save(std::ofstream OutFile);
 void Load(std::ifstream inFile);
}
void Drawing::Save(std::ofstream& outFile)
{
 for(each element in the drawing)
 {
  (current element()->Save(outFile));
 }
}
根据DrawingType产生对象
namespace DrawingType
{
 const int
 Line =1,
 POLYGON=2,
 CIRCLE=3
};
void Drawing::Load(std::ifstream& inFile)
{
 while(inFile)
 {
  int drawingType;
  inFile>>drawingType;
  Shape* pCurrentObject;
  switch(drawingType)
  using namespace DrawingType;
  case LINE:
   pCurrentObject=new Line;
   break;
  case: POLYGON
   pCurrentObjecct=new Polygon;
   break;
 }
}

map存储对象
class ShapeFactory
{
 public :
 typedef Shape* (*CreateShapeCallback)();
 private:
 tyepdef std::map<int ,CreateShapeCallback>CallbackMap;
 public:
 bool RegisterShape(int ShapeId,CreateShapeCallback CreateFn);
 bool UnregisterShape(int ShapeId);
 Shape*CreateShape(int ShapeId);
 private:
 CallbackMap callbacks_;
}

泛化工程模式
template <
class AbstractProduct,
typename  IdentifierType
typename  ProductCreator
tempalte<typename ,class> class FactoryErrorPolicy
>
class Factor
{
 public:
 bool Register(const IdentifierType&id,ProductCreator creator)
 {
  return asociation_.insert(AssocMap::value_type(id,creator)).second;
 }
 bool Unregister(const IdentifierType& id)
 {
  return associations_.erase(id)==1;
 }
 AbstractProduct* CreateObject(const IdentifierType &od)
 {
  typename AssocMap::const_iterator i= association_.find(id);
  if(i !=associations_.end())
  {
   return (i->second)();
  }
  return OnUnknownType(id);
 }
 private:
 typedef std::map<IdentifierType,AbstractProduct> AssocMap;
 AssocMap associations_;
};
template<class IndentifierType,class ProcductType>
class DefaultFactorError
{
 pubclic Execption:publcid std::exception
 {
  public :
  Exception(const IdentifierType& unknowId):unknownId_(unknownId)
  {

  }
  virtual const char * what()
  {
   return "Unknow";
  }
  const IdentifierType GetId()
  {
   return unknowId_;
  }
  private:
  IdentifierType unknownId_;
 }
 protected:
 StaticProductType* OnUnknownType(const IdentifierType&id)
 {
  throw Exception(id);
 }
}