The situation when a single point in my application must control the release of a given resource is when I use shared_ptr internally and give out weak_ptr's to other objects that must reference the resource.

This prevents references to deleted memory, and all of the bizarre errors that that can lead to, and has the upside of being easier to debug. It's not a panacea, but it converts a class of really nasty errors, to something more manageable.

Avoid shared_ptr's in the binding of callbacks/events from sources/producers since they will keep the observer/consumer/sink object alive when its the only reference having a hold on the object. my approach is to bind a weak_ptr<> and test whether its alive before either calling or erasing the partially bound method from the event source site. An alternative approach would be to use a sort of reverse notification and employ an event which gets sent back to to the event producer to tell it to unbind the observers bound method when the observer is destroyed. its possible to place these in the custom Deleter of the shared_ptr that holds the observer but it feels a bit unnatural and over-engineered.

Also I think shared_ptr's can almost imply structuring an applications object graph in a tree structure otherwise you run a high risk of circular dependencies - possibly a very judicious use of weak references could be used to mitigate but the chances of something going wrong is high and it feels a bit like a workaround hack to me. there's a bit of an analogy here with the MS-office object models that use reference counted COM components and the manner in which they are structured in a tree like pattern as a means to avoid cyclic graphs/dependencies.

otherwise shared_ptr's are the best thing to happen to c++. One case where its possible to consider extending the use of shared pointer application is for resources that are not memory. You are permitted to pass a custom resource cleanup function to the shared pointer in place of the default delete. In effect you can define the policy for clean-up at the point of assignment.

An example from some db wrapper code of mine where the c api cleanup function PQfinish() for a database connection is bound as the custom deleter of the shared pointer.

/* Make a connection to the database */
PGconn *conn1 = PQconnectdb(conninfo.c_str());
/* bind clean up function */
shared_ptr< PGconn> conn( conn1, bind( &PQfinish, _1));

This feels cleaner to me than holding the raw pointer in an enclosing class and then remembering to call PQfinish() in that classes destructor to guarantee the connection wont leak if an exception is called.