Which kind of pointer do I use when?

by

Shared ownership:
The shared_ptr and weak_ptr the standard adopted are pretty much the same as their Boost counterparts. Use them when you need to share a resource and don’t know which one will be the last to be alive. Use weak_ptr to observe the shared resource without influencing its lifetime, not to break cycles. Cycles with shared_ptr shouldn’t normally happen – two resources can’t own each other.

Note that Boost additionally offers shared_array, which might be a suitable alternative to shared_ptr<std::vector<T> const>.

Next, Boost offers intrusive_ptr, which are a lightweight solution if your resource offers reference-counted management already and you want to adopt it to the RAII principle. This one was not adopted by the standard.

Unique ownership:
Boost also has a scoped_ptr, which is not copyable and for which you can not specify a deleter. std::unique_ptr is boost::scoped_ptr on steroids and should be your default choice when you need a smart pointer. It allows you to specify a deleter in its template arguments and is movable, unlike boost::scoped_ptr. It is also fully usable in STL containers as long as you don’t use operations that need copyable types (obviously).

Note again, that Boost has an array version: scoped_array, which the standard unified by requiring std::unique_ptr<T[]> partial specialization that will delete[] the pointer instead of deleteing it (with the default_deleter). std::unique_ptr<T[]> also offers operator[] instead of operator* and operator->.

Note that std::auto_ptr is still in the standard, but it is deprecated.
§D.10 [depr.auto.ptr]

The class template auto_ptr is deprecated. [ Note: The class template unique_ptr (20.7.1) provides a better solution. —end note ]

No ownership:
Use dumb pointers (raw pointers) or references for non-owning references to resources and when you know that the resource will outlive the referencing object / scope. Prefer references and use raw pointers when you need either nullability or resettability.

If you want a non-owning reference to a resource, but you don’t know if the resource will outlive the object that references it, pack the resource in a shared_ptr and use a weak_ptr – you can test if the parent shared_ptr is alive with lock, which will return a shared_ptr that is non-null if the resource still exists. If want to test whether the resource is dead, use expired. The two may sound similar, but are very different in the face of concurrent execution, as expired only guarantees its return value for that single statement. A seemingly innocent test like

if(!wptr.expired())
  something_assuming_the_resource_is_still_alive();

is a potential race condition.

More Related Contents:

  1. What is a smart pointer and when should I use one?
  2. Why should I use a pointer rather than the object itself?
  3. What are the differences between a pointer variable and a reference variable in C++?
  4. When should static_cast, dynamic_cast, const_cast and reinterpret_cast be used?
  5. What is a lambda expression in C++11?
  6. What are rvalues, lvalues, xvalues, glvalues, and prvalues?
  7. C++ delete – It deletes my objects but I can still access the data?
  8. What does T&& (double ampersand) mean in C++11?
  9. Why can I not push_back a unique_ptr into a vector?
  10. What is the point of function pointers?
  11. How can I efficiently select a Standard Library container in C++11?
  12. Is there any use for unique_ptr with array?
  13. Is the safe-bool idiom obsolete in C++11?
  14. Why is `std::move` named `std::move`?
  15. Why is ‘this’ a pointer and not a reference?
  16. What are the advantages of using nullptr?
  17. What are the differences between a pointer variable and a reference variable?
  18. When should I use raw pointers over smart pointers?
  19. smart pointers and arrays
  20. Constexpr pointer value
  21. std::shared_ptr initialization: make_shared() vs shared_ptr(new Foo) [duplicate]
  22. Where is shared_ptr?
  23. What are the main purposes of std::forward and which problems does it solve?
  24. std::auto_ptr to std::unique_ptr
  25. Why is auto_ptr being deprecated?
  26. Why does pointer to int convert to void* but pointer to function convert to bool?
  27. Conversion from Derived** to Base**
  28. Why would I std::move an std::shared_ptr?
  29. C++11: Replace all non-owning raw pointers with std::shared_ptr()?
  30. What does ‘dereferencing’ a pointer mean in C/C++?

Leave a Comment