[boost] plain pointers and shared_ptr

From: E. Gladyshev (egladysh_at_[hidden])
Date: 2002-03-22 14:10:36

In my previous post, I looked at using shared_ptr<>
with plain pointers.
The problem is that if a caller passes an object to a
function with a 
plain pointer, the caller has to make sure that the
object is
valid while the function is using this object.
In other words a function cannot claim a shared
owenership of an object
if the object is passed in with a plain pointer.  This
issue
is especially important in multi-threaded
applications.
The following code won't work of course.

void foo( int* p )
{
        shared_ptr<int> my_int( p );  //claim shared
ownership
}

main()
{
        shared_ptr<int> x( new int );
        foo( x.get() );
}  //!!CRASH  shared_ptr<> will try to delete an
object that has been deleted by foo().

A very easy solution is to use a global object map.  
STL has a logarithmic <map> class.  The following 
code shows how to do that.  This is just a test code.
Do you think if it is a valid idea to be included in
boost?

#include <map>
using namespace std;

typedef map<void*, int*> object_map;

class smart_ptr_base
{
protected:
        static object_map _map;
};

template <typename T>
class smart_ptr : public smart_ptr_base
{
public:

        smart_ptr( T* d )
        {
                pair<object_map::iterator, bool>  p;
                p = _map.insert( object_map::value_type( d, new int
) );
                _it = p.first;
                if( p.second ) *(p.first->second) = 1;
                else ++*(p.first->second);
        }

        virtual ~smart_ptr()
        {
                if( !--*(_it->second) )
                {
                        delete (T*)(_it->first);
                        _map.erase( _it );
                }
        }

        //all other standard smart pointer stuff goes here
        //...

protected:
        object_map::iterator _it;
};

object_map smart_ptr_base::_map;

void foo( A* p )
{
        smart_ptr<A> tmp( p );  //claim shared ownership
}

int main(int argc, char* argv[])
{
        A *p = new A();
        smart_ptr<A> tmp( p );
        foo( p );
        return 0;
}

One problem that I'd like to solve is to deal with
pointers 
to static objects.
I am not sure if there are any smart pointer
implementations that
can reference static objects.  For example:

int g_x;
int main()
{
        share_ptr<int> tmp(&g_x)
}	//CRASH

__________________________________________________
Do You Yahoo!?
Yahoo! Movies - coverage of the 74th Academy Awards®
http://movies.yahoo.com/