Differences between unique ptr and shared ptr

Question

Possible Duplicates    pimpl  shared ptr or unique ptr   smart pointers  boost  explained       Could someone explain differences between shared ptr and unique ptr

User · Answer

unique ptr is a smart pointer which owns an object exclusively   shared ptr is a smart pointer for shared ownership  It is both copyable and movable  Multiple smart pointer instances can own the same resource  As soon as the last smart pointer owning the resource goes out of scope  the resource will be freed

User · Answer

Both of these classes are smart pointers  which means that they automatically  in most cases  will deallocate the object that they point at when that object can no longer be referenced   The difference between the two is how many different pointers of each type can refer to a resource   When using unique ptr  there can be at most one unique ptr pointing at any one resource     When that unique ptr is destroyed  the resource is automatically reclaimed   Because there can only be one unique ptr to any resource  any attempt to make a copy of a unique ptr will cause a compile-time error   For example  this code is illegal   unique ptr lt T gt  myPtr new T            Okay unique ptr lt T gt  myOtherPtr   myPtr     Error  Can t copy unique ptr   However  unique ptr can be moved using the new move semantics   unique ptr lt T gt  myPtr new T                       Okay unique ptr lt T gt  myOtherPtr   std  move myPtr      Okay  resource now stored in myOtherPtr   Similarly  you can do something like this   unique ptr lt T gt  MyFunction         unique ptr lt T gt  myPtr                                 return myPtr      This idiom means  I m returning a managed resource to you   If you don t explicitly capture the return value  then the resource will be cleaned up   If you do  then you now have exclusive ownership of that resource    In this way  you can think of unique ptr as a safer  better replacement for auto ptr   shared ptr  on the other hand  allows for multiple pointers to point at a given resource   When the very last shared ptr to a resource is destroyed  the resource will be deallocated   For example  this code is perfectly legal   shared ptr lt T gt  myPtr new T            Okay shared ptr lt T gt  myOtherPtr   myPtr     Sure   Now have two pointers to the resource    Internally  shared ptr uses reference counting to track how many pointers refer to a resource  so you need to be careful not to introduce any reference cycles   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    Hope this helps

User · Answer

unique ptr is the light-weight smart pointer of choice if you just have a dynamic object somewhere for which one consumer has sole  hence  unique   responsibility -- maybe a wrapper class that needs to maintain some dynamically allocated object  unique ptr has very little overhead  It is not copyable  but movable  Its type is template  lt typename D  typename Deleter gt  class unique ptr   so it depends on two template parameters   unique ptr is also what auto ptr wanted to be in the old C   but couldn t because of that language s limitations   shared ptr on the other hand is a very different animal  The obvious difference is that you can have many consumers sharing responsibility for a dynamic object  hence  shared    and the object will only be destroyed when all shared pointers have gone away  Additionally you can have observing weak pointers which will intelligently be informed if the shared pointer they re following has disappeared   Internally  shared ptr has a lot more going on  There is a reference count  which is updated atomically to allow the use in concurrent code  Also  there s plenty of allocation going on  one for an internal bookkeeping  reference control block   and another  often  for the actual member object   But there s another big difference  The shared pointers type is always template  lt typename T gt  class shared ptr   and this is despite the fact that you can initialize it with custom deleters and with custom allocators  The deleter and allocator are tracked using type erasure and virtual function dispatch  which adds to the internal weight of the class  but has the enormous advantage that different sorts of shared pointers of type T are all compatible  no matter the deletion and allocation details  Thus they truly express the concept of  shared responsibility for T  without burdening the consumer with the details   Both shared ptr and unique ptr are designed to be passed by value  with the obvious movability requirement for the unique pointer   Neither should make you worried about the overhead  since their power is truly astounding  but if you have a choice  prefer unique ptr  and only use shared ptr if you really need shared responsibility

User · Answer

When wrapping a pointer in a unique ptr you cannot have multiple copies of unique ptr  The shared ptr holds a reference counter which count the number of copies of the stored pointer  Each time a shared ptr is copied  this counter is incremented  Each time a shared ptr is destructed  this counter is decremented  When this counter reaches 0  then the stored object is destroyed

[c++] Differences between unique_ptr and shared_ptr

Examples related to c++

Examples related to pointers

Examples related to c++11

Examples related to shared-ptr

Examples related to unique-ptr