Introduction to Smart Pointers in Modern C++

Smart Pointers were introduced by C++11 Standard. Smart pointers are a significant advancement that addresses the longstanding challenge of memory management in C++ programming.

The Problem of Memory Management

Traditionally, managing memory in C++ has involved two primary operations: allocating memory with the new operator and releasing it using the delete operator.

int * ptr = new int(4);

delete ptr;
ptr = NULL;

This manual process is prone to errors, particularly in large-scale projects spread across hundreds or thousands of files, where it’s all too easy to forget to free allocated memory.

void someFunction()
        int * ptr = new int(4);
    // Pointer ptr goes out of scope
    // but memory allocated on heap never deleted
    // It is a Memory Leak

Such oversight leads to memory leaks, a serious issue that can degrade performance and reliability.

Automatic Memoty Management using Smart Pointer

Smart pointers offer a solution to this problem by wrapping raw pointer operations, particularly the delete operation. With smart pointers, you no longer need to manually release memory. Instead, when a smart pointer goes out of scope, it automatically handles the deallocation of the memory it manages, similar to how local stack variables are treated.

This automatic memory management emulates the convenience of stack variables and ensures safer code by reducing the risk of memory leaks and dangling pointers.

Types of Smart Pointers

In modern C++, smart pointers are part of the <memory> header file, which must be included to use them. There are three primary types of smart pointers:

  1. Unique Pointers (std::unique_ptr): These pointers maintain exclusive ownership of the underlying memory. They cannot be copied, ensuring that only one unique_ptr can own a particular memory resource at a time.
  2. Shared Pointers (std::shared_ptr): Shared pointers allow multiple owners of the same memory. They use reference counting to track how many shared_ptr instances are managing the same resource, and the memory is only released when the last shared_ptr is destroyed.
  3. Weak Pointers (std::weak_ptr): These are non-owning smart pointers that reference an object managed by shared_ptr without affecting its reference count. They are used to break circular references that can cause memory leaks with shared_ptr.

Starting with Smart Pointers

Let’s look at an example using std::unique_ptr to get you started:

#include <iostream>
#include <memory>

int main()
    std::unique_ptr<int> spObj(new int(10));

    // Access the data at memory using Smart Pointer
    std::cout << "Value: " << *spObj << std::endl;

    // No need to delete, memory is freed automatically 
    // when the Smart Pointer object goes out of scope.
    return 0;


Value: 10

In the example above, you see that we allocated an integer on the heap and wrapped it with a unique_ptr. We didn’t need to call delete because the unique_ptr takes care of deallocating the memory when it goes out of scope.


We just gave an introduction to Smart Pointers in C++. As we move through this series in upcoming articles, we will look deeper into each type of smart pointer, their uses, best practices, and the nuances that make them indispensable tools for modern C++ developers.

Leave a Comment

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Scroll to Top