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?

Answer 1

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".