std::unique_ptr vs std::shared_ptr vs std::weak_ptr vs std::auto_ptr vs raw pointers

Question

What are the equivalent uses of each smart pointer in comparison to similar (but not limited to) some advanced techniques using raw pointers?

My understanding is minimal, but from what I can gather:

Raw Pointers: Only use if you really, really, really, really, know what you are doing and have carefully hidden usage behind an interface.
std::auto_ptr: Obsolete never use.
std::unique_ptr: Singleton pointer that transfers ownership upon assignment.
std::shared_ptr: Reference counted pointer that does not transfer ownership upon assignment but increments its reference count. When all references leave scope or are explicitly std::shared_ptr::reset the underlying deallocator is called.
std::weak_ptr: A sub-type std::shared_ptr that does not increment the reference count and is invalidated when its parent std::shared_ptr no longer exists. May return and invalid reference. Always check before using.

RAW POINTER EQUIVALENT EXAMPLES

Reference counting, cache implementations: std::map<std::string, std::pair<long, BITMAP*> > _cache;

Singletons with transfer of ownership:

class Keyboard {
public:
//...
    static Keyboard* CreateKeyboard();
    ~Keyboard();
//...
private:
//...
    Keyboard();
    static Keyboard* _instance;
//...
};

Aggregate Containers, no ownership: Spatial partitioning graphs and trees, iterative containers, etc.

Composite Containers, ownership: Large objects.

--EDIT--

As I am working I came upon an interesting case, DeadMG pointed out that smart pointers are supposed to be used as easy abstractions to take care of resource management; what about file-scope objects that can not be created on the heap at the point of declaration but instead must be created at a later time?

I don't understand what you are asking. How to implement smart pointer behavior with raw pointers? — Neil Kirk
I have no idea what this question is, but if you're calling unique_ptr a Singleton pointer, I suspect you have a totally different meaning of Singleton here. — Puppy
@Casey: You might want to consider editing that into your question. — Puppy
@Casey: No, there is only one unique_ptr per resource. And even that can be a bit flexible if you start to screw around with custom deleters that do things other than destroy the resource completely. — Puppy
@DeadMG Ohhh, so it's a one-to-one relationship instead of std::shared_ptrs one-to-many. — Casey

Puppy Puppy · Accepted Answer · 2013-08-16T02:23:31

what idiom is each smart pointer supposed to replace?

Every single one of them, ever, that eventually involved destroying the pointed-to resource. So in other words, virtually all of them. I can think of no idioms involving raw pointers that did not involve destroying a pointed-to resource. Every other use isn't really an idiom, it's just "Using a pointer".

std::unique_ptr vs std::shared_ptr vs std::weak_ptr vs std::auto_ptr vs raw pointers

1 Answers