Question

I have an application that has several objects (about 50 so far, but growing). There is only one instance of each of these objects in the app and these instances get shared among components.

What I’ve done is derive all of the objects from a base BrokeredObject class:

class BrokeredObject {   virtual int GetInterfaceId() = 0; }; 

And each object type returns a unique ID. These IDs are maintained in a header file.

I then have an ObjectBroker ‘factory’. When someone needs an object, then call GetObjectByID(). The boker looks in an STL list to see if the object already exists, if it does, it returns it. If not, it creates it, puts it in the list and returns it. All well and good.

BrokeredObject *GetObjectByID(int id) {   BrokeredObject *pObject;   ObjectMap::iterator = m_objectList.find(id);   // etc.   if(found) return pObject;    // not found, so create   switch(id)   {     case 0: pObject = new TypeA; break;     case 1: pObject = new TypeB; break;     // etc.     // I loathe this list   }   // add it to the list   return pObject; } 

What I find painful is maintaining this list of IDs and having to have each class implement it. I have at least made my consumer’s lives slightly easier by having each type hold info about it’s own ID like this:

class TypeA : public BrokeredObject {   static int get_InterfaceID() { return IID_TYPEA; }   int GetInterfaceID() { return get_InterfaceID(); } }; 

So I can get an object like this:

GetObjectByID(TypeA::get_InterfaceID()); 

Intead of having to actually know what the ID mapping is but I still am not thrilled with the maintenance and the potential for errors. It seems that if I know the type, why should I also have to know the ID?

What I long for is something like this in C#:

BrokeredObject GetOrCreateObject<T>() where T : BrokeredObject {   return new T(); } 

Where the ObjectBroker would create the object based on the type passed in.

Has C# spoiled me and it’s just a fact of life that C++ can’t do this or is there a way to achieve this that I’m not seeing?

Answer 1

My use-case tended to get a little more complex – I needed the ability to do a little bit of object initialization and I needed to be able to load objects from different DLLs based on configuration (e.g. simulated versus actual for hardware). It started looking like COM and ATL was where I was headed, but I didn’t want to add the weight of COM to the OS (this is being done in CE).

What I ended up going with was template-based (thanks litb for putting me on track) and looks like this:

class INewTransModule {   public:     virtual bool Init() { return true; }     virtual bool Shutdown() { return true; } };  template <typename T> struct BrokeredObject { public:     inline static T* GetInstance()   {     static T t;     return &t;   } };  template <>  struct BrokeredObject<INewTransModule> { public:     inline static INewTransModule* GetInstance()   {     static INewTransModule t;     // do stuff after creation     ASSERT(t.Init());     return &t;   } };  class OBJECTBROKER_API ObjectBroker {   public:      // these calls do configuration-based creations     static ITraceTool  *GetTraceTool();     static IEeprom     *GetEeprom();     // etc }; 

Then to ensure that the objects (since they’re templated) actually get compiled I added definitions like these:

class EepromImpl: public BrokeredObject<EepromImpl>, public CEeprom { };  class SimEepromImpl: public BrokeredObject<SimEepromImpl>, public CSimEeprom { };