So here's a problem that I've run into. I have a class defined thus:

class Savable
{
    // some pure virtual methods
    virtual void saveYourself(boost::shared_ptr<Saver> saver) = 0;
}

And another class that implements the above:

class SomeClass : Savable
{
    // implements Savable methods
}

Finally, I have a class that writes a Savable to disk:

class Saver
{
    virtual void save(boost::shared_ptr<Savable> saveMe);
}

Now, there might be the case where SomeClass calls Saver because it wants to save itself because the end user has a subclass that writes to disk in it's own special way. Now, I know I can't call Saver::save() like this:

boost::shared_ptr me(this);
saver->save(me);

because the shared_ptr would try to delete *this when it goes out of scope. And I didn't see any way in shared_ptr to release the pointer. What is a good way to work around this?

You can either use a null deleter and pass it in when you construct your shared pointer, or you can use enable_shared_from_this.

But if you are already using Boost, why don't you take a look at Boost.Serialization?


jfl.

[Edit: You should probably read all of the Programming Techniques for shared_ptr.]

Looks like the null deleter is exactly what I want. The enable_shared_from_this would only work if the class knew that another shared_ptr to *this existed. Thanks for the quick response! Rating++!

You're welcome. Still, I do recommend you take a look at the Serialization library. It does pretty much exactly what you are trying to do, and then some.