Should I use shared_ptr or unique_ptr

by

I’ve been making some objects using the pimpl idiom, but I’m not sure whether to used shared_ptr or unique_ptr.

Definitely unique_ptr or scoped_ptr.

Pimpl is not a pattern, but an idiom, which deals with compile-time dependency and binary compatibility. It should not affect the semantics of the objects, especially with regard to its copying behavior.

You may use whatever kind of smart pointer you want under the hood, but those 2 guarantee that you won’t accidentally share the implementation between two distinct objects, as they require a conscious decision about the implementation of the copy constructor and assignment operator.

However, these objects in a way really aren’t being copied, as changes affect all copies, so I was wondering that perhaps using shared_ptr and allowing copies is some sort of anti-pattern or bad thing.

It is not an anti-pattern, in fact, it is a pattern: Aliasing. You already use it, in C++, with bare pointers and references. shared_ptr offer an extra measure of “safety” to avoid dead references, at the cost of extra complexity and new issues (beware of cycles which create memory leaks).

Unrelated to Pimpl

I understand unique_ptr is more efficient, but this isn’t so much of an issue for me, as these objects are relatively heavyweight anyway so the cost of shared_ptr over unique_ptr is relatively minor.

If you can factor out some state, you may want to take a look at the Flyweight pattern.

More Related Contents:

  1. Differences between unique_ptr and shared_ptr [duplicate]
  2. How do I use unique_ptr for pimpl?
  3. Why does unique_ptr take two template parameters when shared_ptr only takes one?
  4. Does C++11 unique_ptr and shared_ptr able to convert to each other’s type?
  5. Is std::unique_ptr required to know the full definition of T?
  6. Why can I not push_back a unique_ptr into a vector?
  7. shared_ptr to an array : should it be used?
  8. Returning unique_ptr from functions
  9. How do I pass a unique_ptr argument to a constructor or a function?
  10. How do I use a custom deleter with a std::unique_ptr member?
  11. Is there any use for unique_ptr with array?
  12. How to capture a unique_ptr into a lambda expression?
  13. What constitutes a valid state for a “moved from” object in C++11?
  14. Copy constructor for a class with unique_ptr
  15. Why isn’t there a std::shared_ptr specialisation?
  16. Does the GotW #101 “solution” actually solve anything?
  17. Passing shared pointers as arguments
  18. Proper way to create unique_ptr that holds an allocated array
  19. std::shared_ptr initialization: make_shared() vs shared_ptr(new Foo) [duplicate]
  20. So can unique_ptr be used safely in stl collections?
  21. Where is shared_ptr?
  22. std::unique_ptr, deleters and the Win32 API
  23. std::auto_ptr to std::unique_ptr
  24. How does the custom deleter of std::unique_ptr work?
  25. How can I pass std::unique_ptr into a function
  26. What is the difference between an empty and a null std::shared_ptr in C++?
  27. shared_ptr is to weak_ptr as unique_ptr is to… what?
  28. Raw pointer lookup for sets of unique_ptrs
  29. Should std::unique_ptr be permitted
  30. Does std::bind work with move-only types in general, and std::unique_ptr in particular?

Leave a Comment