原始指针管理

Question

Is it appropriate for a class to return aa raw pointer in a "create" method and take a raw pointer argument in its "destroy" method? The aforementioned class stores the pointer in a container and finds/deletes the specified object through the destroy method.

Or should I be using smart pointers? If I understand correctly, smart pointers indicate ownership, but the class is solely responsible for both creation and destruction of the object.

Answer 1

The question is: Can you programatically describe the acquire/release behaviour that the code should have? If yes, ie the behaviour isn't a series of unique events without any pattern, then you can write a handle class that implements this behaviour. Even more, this handle class will be able to guarantee the behaviour, which is what smart pointers are all about. It's not just about correctness of code, but about extended guarantees that make it easier to write correct code.

Also, smart pointers don't always indicate ownership, though they do in most cases. There is also a distinction between shared ownership (shared_ptr) and exclusive ownership (auto_ptr, unique_ptr). Then, there is eg a mere reference without ownership (weak_ptr).

To me, it sounds like you might want to return a shared_ptr with an according deleter. The factory can then eg keep a weak_ptr to retain some access to the according objects, while the shared_ptr guarantees correct cleanup. Make sure you regularly purge expired weak_ptrs from the factories internals though.

In no case would I return a raw pointer. The question this bears is: What should the caller do with it when they are done? Call delete? Call some specific destroy() function? Both of these are better handled by a smart pointer. Also, if the factory retains ownership and reserves itself the right to discard the object at any time, how is the one holding a raw pointer informed about the fact that this pointer will become invalid? A simple answer would be to use a smart pointer that gets notified, like eg weak_ptr.