Example to use shared ptr

Question

Hi I asked a question today about How to insert different types of objects in the same vector array  and my code in that question was    gate  G 1000   G 0    new ANDgate     G 1    new ORgate    gate is a class inherited by ANDgate and ORgate classes class gate                   virtual void Run            A virtual function         class ANDgate  public gate                         void Run              AND version of Run             class ORgate  public gate                         void Run              OR version of Run                    Running the simulator using overloading concept  for                  G i - gt Run        will run perfectly the right Run for the right Gate type       and I wanted to use vectors so someone wrote that I should do that    std  vector lt gate  gt  G  G push back new ANDgate    G push back new ORgate   for unsigned i 0 i lt G size     i      G i - gt Run        but then he and many others suggested that I would better use Boost pointer containers  or shared ptr  I have spent the last 3 hours reading about this topic  but the documentation seems pretty advanced to me       Can anyone give me a small code example of shared ptr usage and why they suggested using shared ptr  Also are there other types like ptr vector  ptr list and ptr deque        Edit1  I have read a code example too that included   typedef boost  shared ptr lt Foo gt  FooPtr          int main       std  vector lt FooPtr gt          foo vector           FooPtr foo ptr  new Foo  2        foo vector push back  foo ptr                    And I don t understand the syntax

User · Answer

Learning to use smart pointers is in my opinion one of the most important steps to become a competent C++ programmer. As you know whenever you new an object at some point you want to delete it.

One issue that arise is that with exceptions it can be very hard to make sure a object is always released just once in all possible execution paths.

This is the reason for RAII: http://en.wikipedia.org/wiki/RAII

Making a helper class with purpose of making sure that an object always deleted once in all execution paths.

Example of a class like this is: std::auto_ptr

But sometimes you like to share objects with other. It should only be deleted when none uses it anymore.

In order to help with that reference counting strategies have been developed but you still need to remember addref and release ref manually. In essence this is the same problem as new/delete.

That's why boost has developed boost::shared_ptr, it's reference counting smart pointer so you can share objects and not leak memory unintentionally.

With the addition of C++ tr1 this is now added to the c++ standard as well but its named std::tr1::shared_ptr<>.

I recommend using the standard shared pointer if possible. ptr_list, ptr_dequeue and so are IIRC specialized containers for pointer types. I ignore them for now.

So we can start from your example:

std::vector<gate*> G; 
G.push_back(new ANDgate);  
G.push_back(new ORgate); 
for(unsigned i=0;i<G.size();++i) 
{ 
  G[i]->Run(); 
}

The problem here is now that whenever G goes out scope we leak the 2 objects added to G. Let's rewrite it to use std::tr1::shared_ptr

// Remember to include <memory> for shared_ptr
// First do an alias for std::tr1::shared_ptr<gate> so we don't have to 
// type that in every place. Call it gate_ptr. This is what typedef does.
typedef std::tr1::shared_ptr<gate> gate_ptr;    
// gate_ptr is now our "smart" pointer. So let's make a vector out of it.
std::vector<gate_ptr> G; 
// these smart_ptrs can't be implicitly created from gate* we have to be explicit about it
// gate_ptr (new ANDgate), it's a good thing:
G.push_back(gate_ptr (new ANDgate));  
G.push_back(gate_ptr (new ORgate)); 
for(unsigned i=0;i<G.size();++i) 
{ 
   G[i]->Run(); 
}

When G goes out of scope the memory is automatically reclaimed.

As an exercise which I plagued newcomers in my team with is asking them to write their own smart pointer class. Then after you are done discard the class immedietly and never use it again. Hopefully you acquired crucial knowledge on how a smart pointer works under the hood. There's no magic really.

User · Answer

The best way to add different objects into same container is to use make shared  vector  and range based loop and you will have a nice  clean and  readable  code   typedef std  shared ptr lt gate gt  Ptr    vector lt Ptr gt  myConatiner   auto andGate   std  make shared lt ANDgate gt     myConatiner push back andGate    auto orGate  std  make shared lt ORgate gt     myConatiner push back orGate    for  auto amp  element   myConatiner      element- gt run

User · Answer

I will add that one of the important things about shared ptr s is to only ever construct them with the following syntax   shared ptr lt Type gt  new Type          This way  the  real  pointer to Type is anonymous to your scope  and held only by the shared pointer   Thus it will be impossible for you to accidentally use this  real  pointer   In other words  never do this   Type  t ptr   new Type       shared ptr lt Type gt  t sptr ptrT t ptr     t ptr is still hanging around   Don t use it    Although this will work  you now have a Type  pointer  t ptr  in your function which lives outside the shared pointer   It s dangerous to use t ptr anywhere  because you never know when the shared pointer which holds it may destruct it  and you ll segfault   Same goes for pointers returned to you by other classes   If a class you didn t write hands you a pointer  it s generally not safe to just put it in a shared ptr   Not unless you re sure that the class is no longer using that object   Because if you do put it in a shared ptr  and it falls out of scope  the object will get freed when the class may still need it

User · Answer

The boost documentation provides a pretty good start example  shared ptr example  it s actually about a vector of smart pointers  or  shared ptr doc The following answer by Johannes Schaub explains the boost smart pointers pretty well  smart pointers explained  The idea behind in as few words as possible  ptr vector is that it handles the deallocation of memory behind the stored pointers for you  let s say you have a vector of pointers as in your example  When quitting the application or leaving the scope in which the vector is defined you ll have to clean up after yourself you ve dynamically allocated ANDgate and ORgate  but just clearing the vector won t do it because the vector is storing the pointers and not the actual objects it won t destroy but what it contains        if you just do  G clear      will clear the vector but you ll be left with 2 memory leaks         to properly clean the vector and the objects behind it for  std  vector lt gate  gt   iterator it   G begin    it    G end    it        delete   it       boost  ptr vector lt   will handle the above for you - meaning it will deallocate the memory behind the pointers it stores

User · Answer

Using a vector of shared ptr removes the possibility of leaking memory because you forgot to walk the vector and call delete on each element   Let s walk through a slightly modified version of the example line-by-line   typedef boost  shared ptr lt gate gt  gate ptr    Create an alias for the shared pointer type   This avoids the ugliness in the C   language that results from typing std  vector lt boost  shared ptr lt gate gt   gt  and forgetting the space between the closing greater-than signs       std  vector lt gate ptr gt  vec    Creates an empty vector of boost  shared ptr lt gate gt  objects       gate ptr ptr new ANDgate     Allocate a new ANDgate instance and store it into a shared ptr   The reason for doing this separately is to prevent a problem that can occur if an operation throws   This isn t possible in this example   The Boost shared ptr  Best Practices  explain why it is a best practice to allocate into a free-standing object instead of a temporary       vec push back ptr     This creates a new shared pointer in the vector and copies ptr into it   The reference counting in the guts of shared ptr ensures that the allocated object inside of ptr is safely transferred into the vector   What is not explained is that the destructor for shared ptr lt gate gt  ensures that the allocated memory is deleted   This is where the memory leak is avoided   The destructor for std  vector lt T gt  ensures that the destructor for T is called for every element stored in the vector   However  the destructor for a pointer  e g   gate   does not delete the memory that you had allocated   That is what you are trying to avoid by using shared ptr or ptr vector

User · Answer

Through Boost you can do it    std  vector lt boost  any gt  vecobj      boost  shared ptr lt string gt  sharedString1 new string  abcdxyz              boost  shared ptr lt int gt  sharedint1 new int 10        vecobj push back sharedString1       vecobj push back sharedint1       for inserting different object type in your vector container  while for accessing you have to use any cast  which works like dynamic cast  hopes it will work for your need

User · Answer

include  lt memory gt   include  lt iostream gt   class SharedMemory       public           SharedMemory int  x   capture x            int  get     return   capture get           protected          std  shared ptr lt int gt   capture      int main int   char         SharedMemory   obj1  new SharedMemory new int 10        SharedMemory   obj2   new SharedMemory   obj1       std  cout  lt  lt     obj1     lt  lt    obj1- gt get    lt  lt     obj2     lt  lt    obj2- gt get        lt  lt  std  endl      delete  obj2       std  cout  lt  lt     obj1     lt  lt    obj1- gt get    lt  lt  std  endl      delete  obj1      std  cout  lt  lt    done    lt  lt  std  endl      This is an example of shared ptr in action   obj2 was deleted but pointer is still valid  output is    test   obj1  10  obj2  10   obj2  10  done

[c++] Example to use shared_ptr?

Examples related to c++

Examples related to boost

Examples related to vector

Examples related to shared-ptr

Examples related to smart-pointers