Is there a general smart pointer like auto_ptr and shared_ptr that doesn't need C++0x?

Question

I'm wanting a non-reference counted smart pointer that can combine some of the useful aspects of auto_ptr and shared_ptr. I think that C++0x's unique_ptr is ultimately what I'd need, but I need something that will compile on Visual Studio 2008 and Xcode (gcc 4.2).

The functionality I need is:

• Usable in factory methods so that ownership is transferred on copying (like auto_ptr)
• Supports release() (like auto_ptr)
• Can be used with forward declaration (like shared_ptr)

So, I suppose it's really a better auto_ptr. Is there anything that does this in boost or elsewhere (note: I haven't got the time to wrap my head around Loki)? Or should I just roll my own?

EDIT: I've just been reading more about auto_ptr -- it sounds like you can use it with forward declarations if you ensure that the class header is included in each .cpp file that references the header with the smart pointer (eg see GotW). Anyone got any general advice or rules of thumb on this?

EDIT2: The reason shared_ptr isn't acceptable is because I need a release() method as I'm tidying up some legacy code by introducing factory methods, but it has to co-exist with some manual pointer ownership code. Using shared_ptr throughout the codebase would be great, but a huge task.

EDIT3: In the end, auto_ptr was adequate for the job once I discovered the quirks of the forward inclusion. It would be interesting also to try writing a custom deleter for shared_ptr to allow for optional deletion of the pointer.

Answer 1

Edit: In my original answer, I failed to understand that boost::shared_ptr is not acceptable to you (probably for performance reasons).

auto_ptr does, as you note, support forward declaration. You need to include the header for the referenced class in those places that may destroy the object referenced by the auto_ptr. Note, however, that the semantics of auto_ptr are slightly quirky and require some care.

The answers to the following question contain more information, including the reason why unique_ptr can only be implemented for C++0x because it requires rvalue references:

unique_ptr boost equivalent?

Answer 2

C++ TR1 (supported by modern GCC and Visual Studio) has built-in shared_ptr and others (cf. Wikipedia). Those have mostly been taken from Boost which works for pretty much any modern compiler.

If you need strict ownership, you may check the scoped_ptr.

Answer 3

With some boilerplate code you can approximate unique_ptr in C++03. It's not a perfect emulation. You will need a couple more explicit move calls, for example, to be able to return a local unique_ptr.