Overloading -> operator

I've done a quick google and board search, but didn't turn up any promising results. What I'm trying to do is write a simple class, encapsulating a pseudo-Singleton pointer:

Code:

---

class MySingleton
{
public:
        class Inst
        {
        public:
                Inst() {ptr = MySingleton::getInst();}
                ~Inst() {MySingleton::delRef(ptr);}
                MySingleton* operator-> () {return ptr;}
        protected:
                MySingleton* ptr;
        };
 
        //some data members
 
protected:
        MySingleton();
 
        static MySingleton* ptr;
        static int* refCount;
 
        static MySingleton* getInst();
        static void delRef(MySingleton*& ref);
 
        friend class Inst;
};

---

Currently the class (the pseudo-singleton) just creates the object when getInst() is called and refCount == NULL; delRef checks to see if the pointer passed is a valid pointer to the singleton, and if it is, it decreases *refCount and sets the pointer to NULL, destroying the object/refCount if *refCount reaches zero.

My goal is to create an Inst() class which will get a pointer on creation and release it on destruction, and allow the user to access the singleton's member variables through its -> operator, or something along those lines - but without allowing the user to ever access a pointer to the real thing. Aside from the -> operator, I was thinking of something like defining a conversion operator to MySingleton. Does anyone have ideas about how I might go about doing this?

**EDIT**
Heh nvm, I think I figured it out now (the -> operator really confuses me...). I just had to get operator-> to return a MySingleton* instead of reference, and declare Inst as a friend class of MySingleton :D... Operators are so cool...

**EDIT2**
I fixed the code to reflect my changes (also took out the checking for a valid pointer), for anyone who might be interested.

**EDIT3**
Say, is that how smart-pointers work or something?