What is a smart pointer and when should I use one

Question

User · Answer

Let T be a class in this tutorial Pointers in C++ can be divided into 3 types :

1) Raw pointers :

T a;  
T * _ptr = &a;

They hold a memory address to a location in memory. Use with caution , as programs become complex hard to keep track.

Pointers with const data or address { Read backwards }

T a ; 
const T * ptr1 = &a ; 
T const * ptr1 = &a ;

Pointer to a data type T which is a const. Meaning you cannot change the data type using the pointer. ie *ptr1 = 19 ; will not work. But you can move the pointer. ie ptr1++ , ptr1-- ; etc will work. Read backwards : pointer to type T which is const

  T * const ptr2 ;

A const pointer to a data type T . Meaning you cannot move the pointer but you can change the value pointed to by the pointer. ie *ptr2 = 19 will work but ptr2++ ; ptr2-- etc will not work. Read backwards : const pointer to a type T

const T * const ptr3 ;

A const pointer to a const data type T . Meaning you cannot either move the pointer nor can you change the data type pointer to be the pointer. ie . ptr3-- ; ptr3++ ; *ptr3 = 19; will not work

3) Smart Pointers : { #include <memory> }

Shared Pointer:

  T a ; 
     //shared_ptr<T> shptr(new T) ; not recommended but works 
     shared_ptr<T> shptr = make_shared<T>(); // faster + exception safe

     std::cout << shptr.use_count() ; // 1 //  gives the number of " 
things " pointing to it. 
     T * temp = shptr.get(); // gives a pointer to object

     // shared_pointer used like a regular pointer to call member functions
      shptr->memFn();
     (*shptr).memFn(); 

    //
     shptr.reset() ; // frees the object pointed to be the ptr 
     shptr = nullptr ; // frees the object 
     shptr = make_shared<T>() ; // frees the original object and points to new object

Implemented using reference counting to keep track of how many " things " point to the object pointed to by the pointer. When this count goes to 0 , the object is automatically deleted , ie objected is deleted when all the share_ptr pointing to the object goes out of scope. This gets rid of the headache of having to delete objects which you have allocated using new.

Weak Pointer : Helps deal with cyclic reference which arises when using Shared Pointer If you have two objects pointed to by two shared pointers and there is an internal shared pointer pointing to each others shared pointer then there will be a cyclic reference and the object will not be deleted when shared pointers go out of scope. To solve this , change the internal member from a shared_ptr to weak_ptr. Note : To access the element pointed to by a weak pointer use lock() , this returns a weak_ptr.

T a ; 
shared_ptr<T> shr = make_shared<T>() ; 
weak_ptr<T> wk = shr ; // initialize a weak_ptr from a shared_ptr 
wk.lock()->memFn() ; // use lock to get a shared_ptr 
//   ^^^ Can lead to exception if the shared ptr has gone out of scope
if(!wk.expired()) wk.lock()->memFn() ;
// Check if shared ptr has gone out of scope before access

See : When is std::weak_ptr useful?

Unique Pointer : Light weight smart pointer with exclusive ownership. Use when pointer points to unique objects without sharing the objects between the pointers.

unique_ptr<T> uptr(new T);
uptr->memFn(); 

//T * ptr = uptr.release(); // uptr becomes null and object is pointed to by ptr
uptr.reset() ; // deletes the object pointed to by uptr

To change the object pointed to by the unique ptr , use move semantics

unique_ptr<T> uptr1(new T);
unique_ptr<T> uptr2(new T);
uptr2 = std::move(uptr1); 
// object pointed by uptr2 is deleted and 
// object pointed by uptr1 is pointed to by uptr2
// uptr1 becomes null

References : They can essentially be though of as const pointers, ie a pointer which is const and cannot be moved with better syntax.

See : What are the differences between a pointer variable and a reference variable in C++?

r-value reference : reference to a temporary object   
l-value reference : reference to an object whose address can be obtained
const reference : reference to a data type which is const and cannot be modified

Reference : https://www.youtube.com/channel/UCEOGtxYTB6vo6MQ-WQ9W_nQ Thanks to Andre for pointing out this question.

User · Answer

Here s a simple answer for these days of modern C    C  11 and later     quot What is a smart pointer  quot   It s a type whose values can be used like pointers  but which provides the additional feature of automatic memory management  When a smart pointer is no longer in use  the memory it points to is deallocated  see also the more detailed definition on Wikipedia    quot When should I use one  quot   In code which involves tracking the ownership of a piece of memory  allocating or de-allocating  the smart pointer often saves you the need to do these things explicitly   quot But which smart pointer should I use in which of those cases  quot   Use std  unique ptr when you want your object to live just as long as a single owning reference to it lives  For example  use it for a pointer to memory which gets allocated on entering some scope and de-allocated on exiting the scope  Use std  shared ptr when you do want to refer to your object from multiple places - and do not want your object to be de-allocated until all these references are themselves gone  Use std  weak ptr when you do want to refer to your object from multiple places - for those references for which it s ok to ignore and deallocate  so they ll just note the object is gone when you try to dereference   Don t use the boost   smart pointers or std  auto ptr except in special cases which you can read up on if you must     quot Hey  I didn t ask which one to use  quot   Ah  but you really wanted to  admit it   quot So when should I use regular pointers then  quot   Mostly in code that is oblivious to memory ownership  This would typically be in functions which get a pointer from someplace else and do not allocate nor de-allocate  and do not store a copy of the pointer which outlasts their execution

User · Answer

The existing answers are good but don t cover what to do when a smart pointer is not the  complete  answer to the problem you are trying to solve   Among other things  explained well in other answers  using a smart pointer is a possible solution to How do we use a abstract class as a function return type  which has been marked as a duplicate of this question  However  the first question to ask if tempted to specify an abstract  or in fact  any  base class as a return type in C   is  what do you really mean    There is a good discussion  with further references  of idiomatic object oriented programming in C    and how this is different to other languages  in the documentation of the boost pointer container library  In summary  in C   you have to think about ownership  Which smart pointers help you with  but are not the only solution  or always a complete solution  they don t give you polymorphic copy  and are not always a solution you want to expose in your interface  and a function return sounds an awful lot like an interface   It might be sufficient to return a reference  for example  But in all of these cases  smart pointer  pointer container or simply returning a reference  you have changed the return from a value to some form of reference  If you really needed copy you may need to add more boilerplate  idiom  or move beyond idiomatic  or otherwise  OOP in C   to more generic polymorphism using libraries like Adobe Poly or Boost TypeErasure

User · Answer

Smart Pointers are those where you don t have to worry about Memory De-Allocation  Resource Sharing and Transfer    You can very well use these pointer in the similar way as any allocation works in Java  In java Garbage Collector does the trick  while in Smart Pointers  the trick is done by Destructors

User · Answer

http   en wikipedia org wiki Smart pointer     In computer science  a smart pointer   is an abstract data type that   simulates a pointer while providing   additional features  such as automatic   garbage collection or bounds checking    These additional features are intended   to reduce bugs caused by the misuse of   pointers while retaining efficiency    Smart pointers typically keep track of   the objects that point to them for the   purpose of memory management  The   misuse of pointers is a major source   of bugs  the constant allocation    deallocation and referencing that must   be performed by a program written   using pointers makes it very likely   that some memory leaks will occur    Smart pointers try to prevent memory   leaks by making the resource   deallocation automatic  when the   pointer to an object  or the last in a   series of pointers  is destroyed  for   example because it goes out of scope    the pointed object is destroyed too

User · Answer

A smart pointer is an object that acts like a pointer  but additionally provides control on construction  destruction  copying  moving and dereferencing   One can implement one s own smart pointer  but many libraries also provide smart pointer implementations each with different advantages and drawbacks   For example  Boost provides the following smart pointer implementations    shared ptr lt T gt  is a pointer to T using a reference count to determine when the object is no longer needed  scoped ptr lt T gt  is a pointer automatically deleted when it goes out of scope  No assignment is possible  intrusive ptr lt T gt  is another reference counting pointer  It provides better performance than shared ptr  but requires the type T to provide its own reference counting mechanism  weak ptr lt T gt  is a weak pointer  working in conjunction with shared ptr to avoid circular references  shared array lt T gt  is like shared ptr  but for arrays of T  scoped array lt T gt  is like scoped ptr  but for arrays of T    These are just one linear descriptions of each and can be used as per need  for further detail and examples one can look at the documentation of Boost   Additionally  the C   standard library provides three smart pointers  std  unique ptr for unique ownership  std  shared ptr for shared ownership and std  weak ptr  std  auto ptr existed in C  03 but is now deprecated

User · Answer

Most kinds of smart pointers handle disposing of the pointer-to object for you  It s very handy because you don t have to think about disposing of objects manually anymore   The most commonly-used smart pointers are std  tr1  shared ptr  or boost  shared ptr   and  less commonly  std  auto ptr  I recommend regular use of shared ptr   shared ptr is very versatile and deals with a large variety of disposal scenarios  including cases where objects need to be  passed across DLL boundaries   the common nightmare case if different libcs are used between your code and the DLLs

User · Answer

A smart pointer is a pointer-like type with some additional functionality  e g  automatic memory deallocation  reference counting etc  A small intro is available on the page Smart Pointers - What  Why  Which   One of the simple smart-pointer types is std  auto ptr  chapter 20 4 5 of C   standard   which allows one to deallocate memory automatically when it out of scope and which is more robust than simple pointer usage when exceptions are thrown  although less flexible  Another convenient type is boost  shared ptr which implements reference counting and automatically deallocates memory when no references to the object remains  This helps avoiding memory leaks and is easy to use to implement RAII  The subject is covered in depth in book  quot C   Templates  The Complete Guide quot  by David Vandevoorde  Nicolai M  Josuttis  chapter Chapter 20  Smart Pointers  Some topics covered   Protecting Against Exceptions Holders   note  std  auto ptr is implementation of such type of smart pointer  Resource Acquisition Is Initialization  This is frequently used for exception-safe resource management in C    Holder Limitations Reference Counting Concurrent Counter Access Destruction and Deallocation

User · Answer

What is a smart pointer  Long version  In principle  https   web stanford edu class archive cs cs106l cs106l 1192 lectures lecture15 15 RAII pdf A modern C   idiom  RAII  Resource Acquisition Is Initialization     When you initialize an object  it should already have    acquired any resources it needs  in the constructor       When an object goes out of scope  it should release every    resource it is using  using the destructor    key point    There should never be a half-ready or half-dead object    When an object is created  it should be in a ready state    When an object goes out of scope  it should release its resources     The user shouldn   t have to do anything more    Raw Pointers violate RAII  It need user to delete manually when the pointers go out of scope  RAII solution is  Have a smart pointer class    Allocates the memory when initialized   Frees the memory when destructor is called   Allows access to underlying pointer  For smart pointer need copy and share  use shared ptr    use another memory to store Reference counting and shared    increment when copy  decrement when destructor    delete memory when Reference counting is 0     also delete memory that store Reference counting   for smart pointer not own the raw pointer  use weak ptr    not change Reference counting   shared ptr usage  correct way  std  shared ptr lt T gt  t1   std  make shared lt T gt  TArgs   std  shared ptr lt T gt  t2   std  shared ptr lt T gt  new T Targs     wrong way  T  pt   new T TArgs      never exposure the raw pointer shared ptr lt T gt  t1   shared ptr lt T gt  pt   shared ptr lt T gt  t2   shared ptr lt T gt  pt    Always avoid using raw pointer  For scenario that have to use raw pointer  https   stackoverflow com a 19432062 2482283 For raw pointer that not nullptr  use reference instead  not use T  use T amp     For optional reference which maybe nullptr  use raw pointer  and which means  T  pt  is optional reference and maybe nullptr  Not own the raw pointer   Raw pointer is managed by some one else  I only know that the caller is sure it is not released now

User · Answer

UPDATE  This answer is rather old  and so describes what was  good  at the time  which was smart pointers provided by the Boost library  Since C  11  the standard library has provided sufficient smart pointers types  and so you should favour the use of std  unique ptr  std  shared ptr and std  weak ptr    There was also std  auto ptr  It was very much like a scoped pointer  except that it also had the  special  dangerous ability to be copied     which also unexpectedly transfers ownership  It was deprecated in C  11 and removed in C  17  so you shouldn t use it   std  auto ptr lt MyObject gt  p1  new MyObject     std  auto ptr lt MyObject gt  p2   p1     Copy and transfer ownership                                       p1 gets set to empty  p2- gt DoSomething       Works  p1- gt DoSomething       Oh oh  Hopefully raises some NULL pointer exception      OLD ANSWER  A smart pointer is a class that wraps a  raw   or  bare   C   pointer  to manage the lifetime of the object being pointed to  There is no single smart pointer type  but all of them try to abstract a raw pointer in a practical way   Smart pointers should be preferred over raw pointers  If you feel you need to use pointers  first consider if you really do   you would normally want to use a smart pointer as this can alleviate many of the problems with raw pointers  mainly forgetting to delete the object and leaking memory   With raw pointers  the programmer has to explicitly destroy the object when it is no longer useful      Need to create the object to achieve some goal MyObject  ptr   new MyObject     ptr- gt DoSomething       Use the object in some way delete ptr     Destroy the object  Done with it     Wait  what if DoSomething   raises an exception       A smart pointer by comparison defines a policy as to when the object is destroyed  You still have to create the object  but you no longer have to worry about destroying it   SomeSmartPtr lt MyObject gt  ptr new MyObject     ptr- gt DoSomething       Use the object in some way      Destruction of the object happens  depending     on the policy the smart pointer class uses      Destruction would happen even if DoSomething       raises an exception   The simplest policy in use involves the scope of the smart pointer wrapper object  such as implemented by boost  scoped ptr or std  unique ptr    void f                  std  unique ptr lt MyObject gt  ptr new MyObject            ptr- gt DoSomethingUseful             ptr goes out of scope --           the MyObject is automatically destroyed          ptr- gt Oops       Compile error   ptr  not defined                        since it is no longer in scope      Note that std  unique ptr instances cannot be copied  This prevents the pointer from being deleted multiple times  incorrectly   You can  however  pass references to it around to other functions you call   std  unique ptrs are useful when you want to tie the lifetime of the object to a particular block of code  or if you embedded it as member data inside another object  the lifetime of that other object  The object exists until the containing block of code is exited  or until the containing object is itself destroyed   A more complex smart pointer policy involves reference counting the pointer  This does allow the pointer to be copied  When the last  reference  to the object is destroyed  the object is deleted  This policy is implemented by boost  shared ptr and std  shared ptr   void f         typedef std  shared ptr lt MyObject gt  MyObjectPtr     nice short alias     MyObjectPtr p1     Empty                MyObjectPtr p2 new MyObject                There is now one  reference  to the created object         p1   p2     Copy the pointer             There are now two references to the object           p2 is destroyed  leaving one reference to the object       p1 is destroyed  leaving a reference count of zero        The object is deleted    Reference counted pointers are very useful when the lifetime of your object is much more complicated  and is not tied directly to a particular section of code or to another object   There is one drawback to reference counted pointers     the possibility of creating a dangling reference      Create the smart pointer on the heap MyObjectPtr  pp   new MyObjectPtr new MyObject       Hmm  we forgot to destroy the smart pointer     because of that  the object is never destroyed    Another possibility is creating circular references   struct Owner      std  shared ptr lt Owner gt  other      std  shared ptr lt Owner gt  p1  new Owner     std  shared ptr lt Owner gt  p2  new Owner     p1- gt other   p2     p1 references p2 p2- gt other   p1     p2 references p1     Oops  the reference count of of p1 and p2 never goes to zero     The objects are never destroyed    To work around this problem  both Boost and C  11 have defined a weak ptr to define a weak  uncounted  reference to a shared ptr

User · Answer

Definitions provided by Chris  Sergdev and Llyod are correct  I prefer a simpler definition though  just to keep my life simple  A smart pointer is simply a class that overloads the - gt   and   operators  Which means that your object semantically looks like a pointer but you can make it do way cooler things  including reference counting  automatic destruction etc  shared ptr and auto ptr are sufficient in most cases  but come along with their own set of small idiosyncrasies

User · Answer

A smart pointer is a class  a wrapper of a normal pointer  Unlike normal pointers  smart point   s life circle is based on a reference count  how many time the smart pointer object is assigned   So whenever a smart pointer is assigned to another one  the internal reference count plus plus  And whenever the object goes out of scope  the reference count minus minus   Automatic pointer  though looks similar  is totally different from smart pointer  It is a convenient class that deallocates the resource whenever an automatic pointer object goes out of variable scope  To some extent  it makes a pointer  to dynamically allocated memory  works similar to a stack variable  statically allocated in compiling time

User · Answer

A smart pointer is like a regular  typed  pointer  like  char    except when the pointer itself goes out of scope then what it points to is deleted as well  You can use it like you would a regular pointer  by using  -    but not if you need an actual pointer to the data  For that  you can use   amp  ptr    It is useful for    Objects that must be allocated with new  but that you d like to have the same lifetime as something on that stack  If the object is assigned to a smart pointer  then they will be deleted when the program exits that function block  Data members of classes  so that when the object is deleted all the owned data is deleted as well  without any special code in the destructor  you will need to be sure the destructor is virtual  which is almost always a good thing to do     You may not want to use a smart pointer when        the pointer shouldn t actually own the data    i e   when you are just using the data  but you want it to survive the function where you are referencing it      the smart pointer isn t itself going to be destroyed at some point  You don t want it to sit in memory that never gets destroyed  such as in an object that is dynamically allocated but won t be explicitly deleted       two smart pointers might point to the same data   There are  however  even smarter pointers that will handle that    that is called reference counting     See also    garbage collection  This stack overflow question regarding data ownership

User · Answer

Here is the Link for similar answers   http   sickprogrammersarea blogspot in 2014 03 technical-interview-questions-on-c 6 html  A smart pointer is an object that acts  looks and feels like a normal pointer but offers more functionality  In C    smart pointers are implemented as template classes that encapsulate a pointer and override standard pointer operators  They have a number of advantages over regular pointers  They are guaranteed to be initialized as either null pointers or pointers to a heap object  Indirection through a null pointer is checked  No delete is ever necessary  Objects are automatically freed when the last pointer to them has gone away  One significant problem with these smart pointers is that unlike regular pointers  they don t respect inheritance  Smart pointers are unattractive for polymorphic code  Given below is an example for the implementation of smart pointers   Example    template  lt class X gt  class smart pointer             public                 smart pointer                                makes a null pointer                smart pointer const X amp  x                makes pointer to copy of x                 X amp  operator                      const X amp  operator     const                 X  operator- gt    const                  smart pointer const smart pointer  lt X gt   amp                   const smart pointer  lt X gt   amp  operator   const smart pointer lt X gt  amp                    smart pointer              private                            This class implement a smart pointer to an object of type X  The object itself is located on the heap  Here is how to use it   smart pointer  lt employee gt  p  employee  Harris  1333     Like other overloaded operators  p will behave like a regular pointer   cout lt  lt  p  p- gt raise salary 0 5

[c++] What is a smart pointer and when should I use one?

Examples related to c++

Examples related to pointers

Examples related to c++11

Examples related to smart-pointers

Examples related to c++-faq