Smart Pointers

Smart Pointers


            Smart pointers come with C++11 standarts.They help us to handling about memory managment topics.In modern languages there are garbage collector that manage the object life times and object's memories.In c++ when we create a object we must be delete the object , otherwise the memory which is used this object will be useless.There are four smart pointer in C++11 , but there are another smart pointers in boot libraries.Since they are not standart I wont cover in this article.

       We must give the flag -std=C++11 in GCC and add the library <memory> when we use the smart pointers.

auto_ptr

     First smart_pointer is auto_ptr.It is not as smart as other smart pointers.When we create object we must be delete when we finished job about this object.

Obje* ptr = new Obje();
ptr->Fonksiyonlar();

delete ptr ;

         But when we forget the deleting there will be extra memory usage.

When define the auto_ptr ;
auto_ptr<T>ptr(new T); We use the this declaration.T is the type of the pointer and ptr is the name.With Ptr-> we can access the object elements and functions.When a auto_ptr assign a object and this object's life time over it deleted automaticlay. It have two useful functions : reset () and release (). reset is kill the object and create a new one , but release is only finished the ownership.

prt.reset(new T); // reset usage
T* p3= ptr.release() ; // ownership finish

delete p3; // delete the pointer 

We cannot use the auto_ptr for STL containers and we shouldn't assign a auto_ptr to another one.Because when assign the first one lose the ownership.

There are a idiom for not losing ownership it is const idiom we can only add the const.

const auto_ptr<Test> pt (new Test(2)); // like a normal auto_ptr

shared_ptr

It is for sharing a object .We can assign two pointers to a object without losing a ownership.We can assign two shared_ptr but never two shared_ptr points to each other because of strong reference counting they cannot be deleted.Declaration of shared_ptr is like auto_ptr

shared_ptr<T> sptr(new T); 
We can use the shared_ptr for the arrays but we must de declare a deletion operation like ;

shared_ptr<int []>p (new int[10],[](int* p) {delete [] p;});

       We a shared object points a object strong reference will one if another one do it will be 2.When the strong reference is zero object will deleted.It is good to sharing a object.But when cyclic reference happen the object cannot be deleted because strong reference never will be 0.For example;

void main()
{
std::shared_ptr<A> x=std::make_shared<A>();


x->ptr = x;// never deleted
}



We can handle this situation with using another smart_pointer weak_ptr

weak_ptr

       weak_ptr using for breaking cyclic reference.But we(programmers) must be investigare where the cyclic reference. weak_ptr cannot be exist without a shared_ptr.weak_ptr take a shared_ptr as a parameter when it is declareted.Like;

weak_ptr<T> wptr(sptr); // sptr : a shared_ptr


We cannot use the -> or . İn weak_ptr.If a weak_ptr assign a shared_ptr strong reference wont increase.So we can the break cyclic reference.
It have two functions : lock and expired ().expired return is expired or not.lock return a shared_ptr whic it assigned.

 We can solve the danglin pointers with using weak_ptr;

unique_ptr

      Last one is unique_ptr. It is like shared_ptr but but there is no sharing thing.a unique_ptr can assign to another one.We can use the unique_ptr for arrays or contaioners without create a delete operation.It have two function reset and release. Reset is reset all thing resource,ownership but release is only finish the ownership.Here a sample code;