C++11: Replace all non-owning raw pointers with std::shared_ptr()?

by

Personally, this is how I (more or less) do it:

  • unique_ptrs are for sole ownership
  • raw pointers mean whoever gave me the raw pointer guarantees the lifetime of that object to match or exceed my lifetime.
  • shared_ptrs are for shared ownership
  • weak_ptrs are for when a system wants to check if the object still exists before using it. This is rare in my code since I find it cleaner to have a system guarantee the lifetime of anything it passes it’s subsystems (in which case I use a raw pointer)

By far I use more unique_ptrs than shared_ptrs, and more raw pointers than weak pointers.

More Related Contents:

  1. What is a smart pointer and when should I use one?
  2. Which kind of pointer do I use when?
  3. Why can I not push_back a unique_ptr into a vector?
  4. Differences between std::make_unique and std::unique_ptr with new
  5. Is there any use for unique_ptr with array?
  6. “Downcasting” unique_ptr to unique_ptr
  7. How much is the overhead of smart pointers compared to normal pointers in C++?
  8. Is there a non-atomic equivalent of std::shared_ptr? And why isn’t there one in ?
  9. C++11 lambda implementation and memory model
  10. smart pointers and arrays
  11. std::shared_ptr initialization: make_shared() vs shared_ptr(new Foo) [duplicate]
  12. Passing shared_ptr as shared_ptr
  13. Where is shared_ptr?
  14. Should I delete the move constructor and the move assignment of a smart pointer?
  15. std::auto_ptr to std::unique_ptr
  16. When is a type in c++11 allowed to be memcpyed?
  17. Why is auto_ptr being deprecated?
  18. unique_ptr and OpenSSL’s STACK_OF(X509)*
  19. Why would I std::move an std::shared_ptr?
  20. Reusing a moved container?
  21. Constexpr Math Functions
  22. Does moving leave the object in a usable state?
  23. Copy constructor is not inherited
  24. Why do auto and template type deduction differ for braced initializers?
  25. C++11 range based loop: How does it really work
  26. std::function and std::bind: what are they, and when should they be used?
  27. What does “Memory allocated at compile time” really mean?
  28. Is auto_ptr deprecated?
  29. C++11 random numbers
  30. Is there a standard way of moving a range into a vector?

Leave a Comment