Does C++11 unique_ptr and shared_ptr able to convert to each other’s type?

by

std::unique_ptr is the C++11 way to express exclusive ownership, but one of its
most attractive features is that it easily and efficiently converts to a std::shared_ptr.

This is a key part of why std::unique_ptr is so well suited as a factory function return type. Factory functions can’t know whether callers will want to use exclusive ownership semantics for the object they return or whether shared ownership (i.e., std::shared_ptr) would be more appropriate. By returning a std::unique_ptr, factories provide callers with the most efficient smart pointer, but they don’t hinder callers from replacing it with its more flexible sibling.

std::shared_ptr to std::unique_ptr is not allowed. Once you’ve turned lifetime management of a resource over to a std::shared_ptr, there’s no changing your mind. Even if the reference count is one, you can’t reclaim ownership of the resource in order to, say, have a std::unique_ptr manage it.

Reference: Effective Modern C++. 42 SPECIFIC WAYS TO IMPROVE YOUR USE OF C++11 AND C++14. Scott Meyers.

In short, you can easily and efficiently convert a std::unique_ptr to std::shared_ptr but you cannot convert std::shared_ptr to std::unique_ptr.

For example:

std::unique_ptr<std::string> unique = std::make_unique<std::string>("test");
std::shared_ptr<std::string> shared = std::move(unique);

or:

std::shared_ptr<std::string> shared = std::make_unique<std::string>("test");

More Related Contents:

  1. Differences between unique_ptr and shared_ptr [duplicate]
  2. Should I use shared_ptr or unique_ptr
  3. Why does unique_ptr take two template parameters when shared_ptr only takes one?
  4. Is std::unique_ptr required to know the full definition of T?
  5. Why can I not push_back a unique_ptr into a vector?
  6. make_unique and perfect forwarding
  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. How to capture a unique_ptr into a lambda expression?
  12. Why isn’t there a std::shared_ptr specialisation?
  13. Why do std::shared_ptr work
  14. How to implement make_unique function in C++11? [duplicate]
  15. Passing shared pointers as arguments
  16. std::shared_ptr initialization: make_shared() vs shared_ptr(new Foo) [duplicate]
  17. So can unique_ptr be used safely in stl collections?
  18. Exception safety and make_unique
  19. Passing shared_ptr as shared_ptr
  20. How can I pass std::unique_ptr into a function
  21. What is the difference between an empty and a null std::shared_ptr in C++?
  22. Raw pointer lookup for sets of unique_ptrs
  23. How do shared pointers work?
  24. unique_ptr and OpenSSL’s STACK_OF(X509)*
  25. How can I compile C++11 code with Orwell Dev-C++?
  26. Why would I std::move an std::shared_ptr?
  27. shared_ptr and weak_ptr differences
  28. weak_ptr, make_shared and memory deallocation
  29. stl container with std::unique_ptr’s vs boost::ptr_container
  30. Is there a way to write make_unique() in VS2012?

Leave a Comment