Smart pointers in C++

A pointer is used to store the address of another variable. In other words, a pointer extracts the information of a resource that is outside the program (heap memory).

We use a copy of the resource, and to make a change, it is done in the copied version. To change the content of the original resource, smart pointers are used.

Problems faced with normal pointers

Below is an example that depicts the problem with normal pointers.

Created a class Rectangle with two data members (length and breadth). A function fun() dynamically creates an object of Rectangle.

When the function fun() ends, the object p gets destroyed. Since we did not delete p, the memory remains allocated, and this allocated resource will not be available to other variables.

In the main(), we execute an infinite loop that will keep creating p objects and allocate resources. This problem turns out into a memory leak to which smart pointers is a solution.

Code

#include <iostream>
using namespace std;

class Rectangle { // created a class Rectangle
private:
	int length; // data member as length of rectangle
	int breadth; // data member as breadth of rectangle

};

void fun() // the function to indicate the problem with normal pointer 
{
	
	Rectangle* p = new Rectangle(); // Create a dynamic object p 
}

int main()
{
	// Infinite Loop
	while (1) { // Run an infinite loop that will allocate p 
		fun();
	}
}

Note - The languages such as JAVA, C# has their garbage collectors that smartly deallocate unused memory resource.

Smart pointers

We will implement smart pointers such that they will release the memory of unused resources.

Create a class with a pointer, overloaded operators(->, *) and destructors.

The destructor will be automatically called when its object goes out of the scope, and automatically the dynamically allocated memory will be deleted.

Example

#include <iostream>
using namespace std;

class SmartPtr { // Create the class to implement smart Pointer
    int* ptr; // Actual pointer
public:
// Create an explicit constructor 
    explicit SmartPtr(int* p = NULL) { ptr = p; }

    // Destructor to deallocate the resource used 
    ~SmartPtr() { delete (ptr); }

    // Overloading dereferencing operator
    int& operator*() { return *ptr; }
};

int main()
{
    SmartPtr ptr(new int());
    *ptr = 100;
    cout << *ptr;

    // We don't need to call delete ptr: when the object
    // ptr goes out of scope, the destructor for it is automatically
    // called, and destructor does delete ptr.

    return 0;
}

Output

The above example works only for int. We will create a template that will work for every data type.

Code

#include <iostream>
using namespace std;

template <class T> // Create a template class 
class SmartPtr {
	T* ptr; // Actual pointer
public:
	// Constructor
	explicit SmartPtr(T* p = NULL) { ptr = p; }

	// Destructor
	~SmartPtr() { delete (ptr); }

	// Overloading dereferncing operator
	T& operator*() { return *ptr; }

	// Overloading arrow operator so that
	// members of T can be accessed
	// like a pointer (useful if T represents
	// a class or struct or union type)
	T* operator->() { return ptr; }
};

int main()
{
	SmartPtr<int> ptr(new int());
	*ptr = 100;
	cout << *ptr;
	return 0;
}

Output

Types of smart pointers

Unique_ptr

This type of object stores only a single object. To assign a different object, current object is deallocated.

Code

#include <iostream>
#include <memory>
using namespace std;


class Rectangle { // Create the class
    // Data members
    int length; // length of rectangle 
    int breadth; // breadth of rectangle 

public:
    Rectangle(int l, int b)
    { // parameterised constructor
        length = l;
        breadth = b;
    }

    int area()
    { // calculate area
        return length * breadth; // return the area 
    }
};

int main()
{

    unique_ptr<Rectangle> P1(new Rectangle(20, 5));
    cout << P1->area() << endl; // This'll print 100

    // unique_ptr<Rectangle> P2(P1);
    unique_ptr<Rectangle> P2;
    P2 = move(P1);

    // This'll print 100
    cout << P2->area() << endl;

    return 0;
}

Output

100
100

Shared_ptr

In shared_ptr, more than one object can point to a single pointer at the same instance of time. A reference counter is maintained for denoting the object using the use_count() method.

Code

#include <iostream>
#include <memory>
using namespace std;

class Rectangle { // Create the class
    // Data members
    int length; // length of rectangle 
    int breadth; // breadth of rectangle 

public:
    Rectangle(int l, int b)
    { // parameterised constructor
        length = l; 
        breadth = b;
    }

    int area()
    { // calculate area of rectangle 
        return length * breadth; // return area 
    }
};

int main()
{

    shared_ptr<Rectangle> P1(new Rectangle(20, 5)); // create shared //ptr P1
    // This'll print 100
    cout << P1->area() << endl;
	// Create shared ptr P2
    shared_ptr<Rectangle> P2;
    P2 = P1;

    // This'll print 100
    cout << P2->area() << endl;

    // This'll now not give an error,
    cout << P1->area() << endl; // prints 100

// reference counter of P2 is 2   
    cout << P1.use_count() << endl; // prints 2 
    return 0;
}

Output

Weak_ptr

Weak_ptr is similar to the shared pointer. The difference is that it does not maintain a reference counter and there is no strong hold of the object on the pointer. This property may result in a deadlock as different objects will try to hold the pointer.

Next TopicTypes of polymorphism in C++

← prev next →