Pointers in standard containers

A long time ago I wrote a simple smart pointer for use in the standard
containers. It doesn't do anything flashy, but it would ensure that
pointers where zero initialised when used in things like maps.

The idea was that if you use a pointer in something like a std::map you
may get things like:

std::map< int, X * > mapx;
std::cout << mapx[ 0 ] << endl; // Might print any old rubbish

This ought to print out a null pointer, but it seemed to me that older
compilers didn't get the initialisation right (I'm specifically
thinking MSVC <= 6 here). So you'd do this instead:

std::map< int, init_ptr< X > > mapx;
std::cout << map[ 0 ] << endl; // Now will print a null pointer

My suspicion though is that this shouldn't be required, but I also
guess that it won't do any harm either. A modern compiler would get the
initialisation correct, but would also strip the init_ptr<> class down
to the extent that it doesn't add any overhead.

Is my thinking on this correct?

An outline of the class is below:

        template< typename P >
        class init_ptr {
        public:
                init_ptr() : m_p( NULL ) {} // This is the point of the class
                init_ptr( P *p ) : m_p( p ) {}

                // Unimportant implementation details cut
        private:
                P *m_p;
        };

      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]