segfault when get_pointer returns null

#ifndef __FUSE_PTR_HPP__
#define __FUSE_PTR_HPP__

#include <map>
#include <iostream>

template<class T>
class fuse_ptr
{
    private:
        // pointer to the object
        T** ptr;
        
        // container for all references from pointers to associated fuse_ptrs
        static std::multimap<T*,fuse_ptr<T> * > fusebox;

    public:
        // contructor for null pointer
        fuse_ptr()
        {
            ptr = new T*;
            *ptr = 0;
        }
        
        // constructor for objects
        fuse_ptr( T* p )
        {
            ptr = new T*;
            *ptr = p;
            std::cout << this << " is now fuse for " << *ptr << std::endl;
            fusebox.insert( std::pair<T*,fuse_ptr<T> * >(p,this) );
        }

        // copy constructor
        fuse_ptr( fuse_ptr const & p )
        {
            ptr = new T*;
            *ptr = *(p.ptr);
            std::cout << this << " is now fuse for " << *ptr << std::endl;
            fusebox.insert( std::pair<T*,fuse_ptr<T> * >(*ptr,this) );
        }
        
        // pointer access
        T* get() const
        {
            std::cout << "Getting ptr of " << this << ": " << *ptr << std::endl;
            return *ptr; 
        }
        
        operator T*() const
        {
            return get();
        }
        
        T* operator->() const
        {
            return get();
        }
        
        operator bool() const
        {
            return get() != 0;
        }
        
        // virtual destructor
        virtual ~fuse_ptr()
        {
            if( *ptr != 0 )
            {
                std::pair< typename std::multimap<T*,fuse_ptr<T> * >::iterator, typename std::multimap<T*,fuse_ptr<T> * >::iterator > range = fusebox.equal_range( *ptr );
                typename std::multimap<T*,fuse_ptr<T> * >::iterator it;
                for( it = range.first; it != range.second && it->second != this; ++it );
                if( it != range.second )
                {
                    std::cout << this << " is not any longer fuse for " << it->first << std::endl;
                    fusebox.erase( it );
                }
            }
            delete ptr;
            ptr = 0;
        }

        // sets all associated fuse_ptrs' contents to null and removes them from fusebox
        static void blow_fuse( T* p )
        {
            std::pair< typename std::multimap<T*,fuse_ptr<T> * >::iterator, typename std::multimap<T*,fuse_ptr<T> * >::iterator > range = fusebox.equal_range( p );
            typename std::multimap<T*,fuse_ptr<T> * >::iterator it;
            for( it = range.first; it != range.second; ++it )
            {
                std::cout << "Setting *ptr of " << it->second << " = 0" << std::endl;
                *(it->second->ptr) = 0;
            }
            fusebox.erase( p );
        }
};

template<class T>
std::multimap<T*,fuse_ptr<T> * > fuse_ptr<T>::fusebox;

// returns p.get()
template<class T>
T* get_pointer( fuse_ptr<T> const & p )
{
    return p.get();
}

#endif

#include <iostream>
#include <sstream>
#include "fuse_ptr.hpp"

#include <lua5.1/lua.hpp>
#include <luabind/luabind.hpp>

using namespace std;
using namespace luabind;

class myclass
{
    public:
    myclass()
    {
        cout << "myclass created: " << this << endl;
        someint = 42;
    }
    myclass(int dummy)
    {
        cout << "myclass created: " << this << endl;
        someint = dummy;
    }
    ~myclass()
    {
        fuse_ptr<myclass>::blow_fuse( this );
        cout << "myclass destructed: " << this << endl;
    }
    virtual void dosomething()
    {
        cout << "someint == " << someint << endl;
    }
    protected:
    int someint;
};

int main(void)
{
    lua_State* L = lua_open();
    luaL_openlibs( L );
    open( L );

    module(L)
        [
        class_<myclass, fuse_ptr<myclass> >("myclass")
        .def( "dosomething", &myclass::dosomething )
        ];

    const char* src = "function doStuff()"
                      "    stored_myc:dosomething();"
                      "end;"
                      "function storeMyc( myc )"
                      "    stored_myc = myc;"
                      "end;";

    if( luaL_dostring( L, src ) )
    {
        cout << "Error:" <<  lua_tostring( L, -1 ) << endl;
    }

    try
    {
        myclass* p = new myclass(100);
        myclass* q = 0;

        // using q here instead of p works
        fuse_ptr<myclass> f(p);
        globals( L )["storeMyc"](f);

        globals( L )["doStuff"]();

        delete p;
        p=0;

        globals( L )["doStuff"]();
        
        delete q;
        q=0;

    }
    catch(luabind::error e)
    {
        cout<<"caught exception..."<<endl;
        cout<<e.what()<<endl;
        std::string err = lua_tostring(L, -1);
        lua_pop(L, 1);
        cout<<err<<endl;
    }
    cout << "closing luaState..." << endl;
    lua_close( L );
    cout << "return 0" << endl;
    return 0;
}