// Pure baseclass Unknown{public:    virtual void grab()=0;    virtual void drop()=0;};// Your classclass MyClass : Unknown{    // MyClass stuff, but do not implement Unknown};// Instantiation wrappertemplate <typename BASE>class Dynamic : public BASE{    int m_iRefCount;public:    Dynamic() { m_iRefCount = 0; }    void grab() { m_iRefCount++; }    void drop() { if ( --m_iRefCount == 0 ) delete this; }};

MyClass *CreateMyClass()  // Example only - returning refcounted objects like this is bad form.{    MyClass *pMyClass = new Dynamic<MyClass>();    pMyClass->grab();    return pMyClass;  }

// .h fileclass MyClass{public:   static MyClass* create();   void release();protected:// Make sure that the only way to create and destroy the object is by using the create/release pair.   MyClass();   ~MyClass();};// .cpp fileMyClass*MyClass::create(){   return new MyClass;}voidMyClass::release(){   delete this;}

// Unknown.hppclass Unknown{private:  int m_RefCount;  inline Unknown() : m_RefCount(0) {} // Private constructor  virtual ~Unknown() {} // Private destructorprotected:  virtual selfDestroy() = 0;public:  inline void grab() { ++m_RefCount; }  inline void drop() { if(--m_RefCount <= 0) selfDestroy(); }  inline int getRefCount() const { return m_RefCount; }  template<class> friend class UnknownBase; // Whatever the syntax for this is};template<class T>class UnknownBase : virtual public Unknown{protected:  inline UnknownBase() {} // Protected constructor  virtual ~UnknownBase() {} // Protected destructorpublic:  static T * Create();};

// Derived.hppclass Derived : public UnknownBase<Derived>{protected:  virtual void selfDestroy();};// Derived.cppDerived * UnknownBase<Derived>::Create() { return new Derived(); }void Derived::selfDestroy() { delete this; }