When to use shared_ptr and when to use raw pointers?

by

Your analysis is quite correct, I think. In this situation, I also would return a bare B*, or even a [const] B& if the object is guaranteed to never be null.

Having had some time to peruse smart pointers, I arrived at some guidelines which tell me what to do in many cases:

  • If you return an object whose lifetime is to be managed by the caller, return std::unique_ptr. The caller can assign it to a std::shared_ptr if it wants.
  • Returning std::shared_ptr is actually quite rare, and when it makes sense, it is generally obvious: you indicate to the caller that it will prolong the lifetime of the pointed-to object beyond the lifetime of the object which was originally maintaining the resource. Returning shared pointers from factories is no exception: you must do this eg. when you use std::enable_shared_from_this.
  • You very rarely need std::weak_ptr, except when you want to make sense of the lock method. This has some uses, but they are rare. In your example, if the lifetime of the A object was not deterministic from the caller’s point of view, this would have been something to consider.
  • If you return a reference to an existing object whose lifetime the caller cannot control, then return a bare pointer or a reference. By doing so, you tell the caller that an object exists and that she doesn’t have to take care of its lifetime. You should return a reference if you don’t make use of the nullptr value.

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. shared_ptr magic :)
  5. Differences between std::make_unique and std::unique_ptr with new
  6. What C++ Smart Pointer Implementations are available?
  7. Is there any use for unique_ptr with array?
  8. smart pointers (boost) explained
  9. “Downcasting” unique_ptr to unique_ptr
  10. Smart pointers: who owns the object? [closed]
  11. How much is the overhead of smart pointers compared to normal pointers in C++?
  12. Is there a non-atomic equivalent of std::shared_ptr? And why isn’t there one in ?
  13. When should I use raw pointers over smart pointers?
  14. smart pointers and arrays
  15. How can I use covariant return types with smart pointers?
  16. std::shared_ptr initialization: make_shared() vs shared_ptr(new Foo) [duplicate]
  17. Passing shared_ptr as shared_ptr
  18. Where is shared_ptr?
  19. Should I delete the move constructor and the move assignment of a smart pointer?
  20. std::auto_ptr to std::unique_ptr
  21. How is it possible (if it is) to implement shared_ptr without requiring polymorphic classes to have virtual destructor?
  22. Can Google Mock a method with a smart pointer return type?
  23. Why is auto_ptr being deprecated?
  24. Is auto_ptr deprecated?
  25. How to break shared_ptr cyclic reference using weak_ptr
  26. Why would I std::move an std::shared_ptr?
  27. Example to use shared_ptr?
  28. C++11: Replace all non-owning raw pointers with std::shared_ptr()?
  29. How to check memory allocation failures with new operator?
  30. How to enable_shared_from_this of both parent and derived

Leave a Comment