Re: Repository of all objects of a certain type

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?