Factory Method

// design_pattern_factory.cpp : Defines the entry point for the console application. // #include "stdafx.h" class Product { }; //----------------------------------------------------------------------------- //first implementation typedef int ProductId; const int MINE = 1; const int YOURS = 2; const int THEIRS = 3; class MyProduct : public Product { int my; }; class YourProduct : public Product { int your; }; class TheirProduct : public Product { int their; }; class Creater { public: virtual Product* Create(ProductId); }; Product* Creater::Create(ProductId id) { if(MINE == id) { return new MyProduct; } if(YOURS == id) { return new YourProduct; } if(THEIRS == id) { return new TheirProduct; } //repeat for remaining products... //... return 0; } class MyCreater : public Creater { public: virtual Product* Create(ProductId); }; Product* MyCreater::Create(ProductId id) { //switched YOURS and MINE if(MINE == id) { return new YourProduct; } if(YOURS == id) { return new MyProduct; } if(THEIRS == id) { return new TheirProduct; } return Creater::Create(id); } //----------------------------------------------------------------------------- //second implementation class Creater2 { public: Product* GetProduct(); virtual Product* CreateProduct(){return new Product;} private: Product* m_Product; }; Product* Creater2::GetProduct() { if(0 == m_Product) { m_Product = CreateProduct(); } return m_Product; } class MyCreater2 : public Creater2 { public: Product* CreateProduct(); }; Product* MyCreater2::CreateProduct() { return new MyProduct; } //----------------------------------------------------------------------------- //third implementation class Creater3 { public: virtual ~Creater3() {} virtual Product* CreateProduct() = 0; }; template <class TheProduct> class StandardCreator: public Creater3 { public: virtual Product* CreateProduct(); }; template <class TheProduct> Product* StandardCreator<TheProduct>::CreateProduct() { return new TheProduct; } class MyProduct3 : public Product { public: MyProduct3(){} private: int my3; }; int _tmain(int argc, _TCHAR* argv[]) { //test first implementation MyCreater my_creater; Product* pProduct = my_creater.Create(1); MyProduct* pMyProduct = (MyProduct*)my_creater.Create(MINE); YourProduct* pYourProduct = (YourProduct*)my_creater.Create(MINE); //test second implementation //... MyCreater2 myCreate2; MyProduct* pMyProduct2 = (MyProduct*)myCreate2.GetProduct(); //test third implementation StandardCreator<MyProduct3> myCreator3; MyProduct3* myproduct3 = (MyProduct3*)myCreator3.CreateProduct(); StandardCreator<YourProduct> yourCreator3; YourProduct* yourproduct3 = (YourProduct*)yourCreator3.CreateProduct(); return 0; } 

 

//example used in tlbb //----------------------------------------------------------------------------- class Packet { }; class PacketFactory { public : virtual ~PacketFactory () {} virtual Packet* CreatePacket () = 0; virtual PacketID_t GetPacketID ()const = 0; virtual UINT GetPacketMaxSize ()const = 0; }; class GCChat : public Packet { }; class GCChatFactory : public PacketFactory { public: Packet* CreatePacket() { return new GCChat() ; } PacketID_t GetPacketID() const { return PACKET_GC_CHAT ; } UINT GetPacketMaxSize()const { return sizeof(BYTE) + sizeof(CHAR)*MAX_CHAT_SIZE; } }; class PacketFactoryManager { public : PacketFactoryManager( ) ; ~PacketFactoryManager( ) ; private : VOID AddFactory( PacketFactory* pFactory ) ; public : BOOL Init( ) ; Packet* CreatePacket( PacketID_t packetID ) ; UINT GetPacketMaxSize( PacketID_t packetID ) ; VOID RemovePacket( Packet* pPacket ) ; VOID Lock( ){ m_Lock.Lock() ; } ; VOID Unlock( ){ m_Lock.Unlock() ; } ; private : PacketFactory ** m_Factories ; USHORT m_Size ; public : UINT* m_pPacketAllocCount ; }; //-----------------------------------------------------------------------------