Does C++11 standard library provide any utility to convert from a std::shared_ptr
to std::unique_ptr
, or vice versa? Is this safe operation?
Afterword. The flawless conversion of an std::unique_ptr to a compatible std::shared_ptr makes it possible to write efficient and safe factory functions. However, note that an std::shared_ptr cannot be converted to an std::unique_ptr.
Use unique_ptr when you want to have single ownership(Exclusive) of the resource. Only one unique_ptr can point to one resource. Since there can be one unique_ptr for single resource its not possible to copy one unique_ptr to another. A shared_ptr is a container for raw pointers.
In short: Use unique_ptr when you want a single pointer to an object that will be reclaimed when that single pointer is destroyed. Use shared_ptr when you want multiple pointers to the same resource.
A unique_ptr does not share its pointer. It cannot be copied to another unique_ptr , passed by value to a function, or used in any C++ Standard Library algorithm that requires copies to be made. A unique_ptr can only be moved.
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 astd::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 astd::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
tostd::unique_ptr
is not allowed. Once you’ve turned lifetime management of a resource over to astd::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 astd::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");
I would prefer to do this.
std::unique_ptr<int> up_ = std::make_unique<int>();
std::shared_ptr<int> sp_ = std::move(up_);
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With