What is the best way to implement smart pointers in C++?

I've been using boost::shared_ptr for several years now and while you are right about the downside (no assignment via pointer possible), I think it was definitely worth it because of the huge amount of pointer-related bugs it saved me from.

In my homebrew game engine I've replaced normal pointers with shared_ptr as much as possible. The performance hit this causes is actually not so bad if you are calling most functions by reference so that the compiler does not have to create too many temporary shared_ptr instances.

Just to supply a different view to the ubiquitous Boost answer (even though it is the right answer for many uses), take a look at Loki's implementation of smart pointers. For a discourse on the design philosophy, the original creator of Loki wrote the book Modern C++ Design.

"What is the best way to implement smart pointers in C++"

1. Don't! Use an existing, well tested smart pointer, such as boost::shared_ptr or std::tr1::shared_ptr (std::unique_ptr and std::shared_ptr with C++ 11)
2. If you have to, then remember to:
   1. use safe-bool idiom
   2. provide an operator->
   3. provide the strong exception guarantee
   4. document the exception requirements your class makes on the deleter
   5. use copy-modify-swap where possible to implement the strong exception guarantee
   6. document whether you handle multithreading correctly
   7. write extensive unit tests
   8. implement conversion-to-base in such a way that it will delete on the derived pointer type (policied smart pointers / dynamic deleter smart pointers)
   9. support getting access to raw pointer
   10. consider cost/benifit of providing weak pointers to break cycles
   11. provide appropriate casting operators for your smart pointers
   12. make your constructor templated to handle constructing base pointer from derived.

And don't forget anything I may have forgotten in the above incomplete list.