Smart pointers in C++

Using pointers in a program increases the risk of memory and resource leaks. Programmers have to make sure that they always free memory (acquired by new operator) using delete operator. Bare pointers in C++ are not exception safe , they do not get destroyed (release memory) if there is an exception in your program.

Smart pointers are helpful to avoid all the problems mentioned above. There are many kinds of smart pointers but in this blog post we will discuss 2 types of smart pointers: unique_ptr and shared_ptr.

What are smart pointers ?
Smart pointers are wrapper over a normal C++ pointer. They are objects that store pointer to dynamically allocated objects. They conceptually own the object pointed to, they delete the object as soon as object is no longer required and goes out of scope.

Difference between normal and smart pointer
The main difference between a normal and smart pointer is that normal pointer do not get deleted unless delete operator is called. On other hand smart pointer deletes the object pointed to as soon as the object goes out of the scope.

Let's try to understand this with a simple example.

void testPointers()
{
    ClassToTest *ct=new ClassToTest(); //normal pointer
    std::unique_ptr<ClassToTest> smartCt(new ClassToTest()); //smart pointer
}
//smartCt gets deleted after this block automatically but ct will not (because no delete operator is called on it) and hence cause a memory leak unless

Types of smart pointers

unique_ptr
A unique_ptr does not share its pointer. Means its a single ownership case. It cannot be used in a scenario where copy of a pointer is required. But its ownership can be moved to another unique_ptr but then the original unique_ptr is no longer the owner of that.It cannot be passed as by value in functions.

To create a unique_ptr you have two ways

//first
unique_ptr<ClassToTest> smartCt1(new ClassToTest());
//second way is to use make_unique helper function
unique_ptr<ClassToTest> smartCt2=make_unique<ClassToTest>();

shared_ptr
shared_ptr is a type of smart pointer that is recommended for situations where multiple owners have to manage the lifetime of an object in memory. It is a reference counted mechanism so when a  new shared_ptr is added the reference count is incremented and whenever shared_ptr goes out of scope or it is reset , reference count is decremented. When reference count reaches 0 the memory of object is released.

Like unique_ptr there are two ways to create shared_ptr

//first
shared_ptr<ClassToTest> sharedC1(new ClassToTest());
//second is using helper function make_sharedshared_ptr<ClassToTest> sharedC2=make_shared<ClassToTest>();

You need to include <memory> header file before using shared_ptr and unique_ptr.