Repository of all objects of a certain type

Hi,

I have an application that uses internal business objects with a primary 
key. For each key at most one instance must exist in memory. Otherwise 
the content will become out of sync. The lifetime is managed by a 
reference counter.


Currently this is implemented like that:

// Base class for the intrusive pointer interface.
class ref_count
{private
   int RefCount;

   template <class T>
   friend class my_intrusive_ptr<T>;
};

template <class K>
class IComareableTo
{ virtual int CompareTo(const K& r) = 0;
};

// Container class that stores pointers to T accessable with the key K
// using the compare expression
//   T* elem;
//   elem->CompareTo(const K& key);
// T must implement ICompareTo<K>.
template <class T, class K>
class sorted_vector_p
{ typedef T* value_type;
   typedef const K& key_type;
   // ...

   // Get an existing or an empty slot in the vector.
   // In the latter case the returned pointer is NULL and the new slot is
   // reserved at the location where an element with the given key must
   // be inserted.
   T*& get(const K& key);
   // Find an existing object or return NULL.
   T* find(const K& key) const;
   // remove a reference or return NULL
   T* erase(const K& key);
};


class MyKey
{public:
   int Key1; // for example
   int Key2;
};

class MyObject : public ref_count, public ICompareableTo<MyKey>
{public:
   const MyKey Key;
  private:
   MyObject(const MyKey& key) : Key(key) {}
  public:
   ~MyObject();

   virtual int CompareTo(const K& r);

   // Repository
  private:
   static sorted_vector_p<MyObject, MyKey> RP_Index;
  public:
   // Factory:
   // Fetches an existing instance or creates a new one for the key K.
   static my_intrusive_ptr<MyObject> GetByKey(const K& key);
   // Fetches an existing instance or return NULL.
   static my_intrusive_ptr<MyObject> FindByKey(const K& key)
   { return RP_Index.find(key); }
};

MyObject::~MyObject()
{ assert(RP_Index.erase(Key) == this);
}

my_intrusive_ptr<MyObject> MyObject::GetByKey(const K& key)
{ MyObject*& ptr = RP_Index.get(key);
   if (!ptr)
     ptr = new MyObject(key);
   return ptr; // Implicit conversion to my_intrusive_ptr
}


This works as expected so far. However I have to copy and adapt the 
static functions and the repository stuff for each type which requires 
an index like that. In fact it is much more than above, because almost 
all public functions are thread-safe.

I would like a more generic solution. But up to now I did not have a 
better idea. At least they require the constructor of MyObject to be
public.

Any recommendations for the above task?


Marcel