Smart pointers are a powerful feature introduced in C++11 that automate memory management, significantly reducing the complexity of manual resource handling. The C++ standard library provides three main types of smart pointers: std::unique_ptr, std::shared_ptr, and std::weak_ptr. std::unique_ptr implements exclusive ownership, ensuring only one pointer can reference a dynamically allocated object at any time. std::shared_ptr enables shared ownership through reference counting, allowing multiple pointers to reference the same object. std::weak_ptr solves the circular reference problem that can occur with std::shared_ptr by not affecting the reference count, allowing safe observation of objects managed by std::shared_ptr. Using smart pointers helps developers avoid common memory management issues like memory leaks and dangling pointers, leading to more robust and reliable code.

Table of Contents

1. The Need for Smart Pointers
2. Memory Leaks 2.1 What are Memory Leaks and Their Dangers 2.2 Types of Memory Leaks 2.3 How to Detect Memory Leaks 2.4 How to Prevent Memory Leaks
3. Smart Pointer Usage and Principles 3.1 RAII Concept 3.2 Smart Pointer Principles 3.3 std::auto_ptr (C++98: Ownership Transfer) 3.4 std::unique_ptr (C++11: Non-copyable) 3.5 std::shared_ptr (C++11: Reference Counted Sharing)
4. The Need for Smart Pointers

In C++, resources allocated with new or malloc must be manually released, which often leads to two problems: first, forgetting to release allocated resources, and second, exception safety issues. Both can result in memory or resource leaks!

#include <iostream>
#include <string>
#include <stdexcept>

int calculateDivision()
{
    int numerator, denominator;
    std::cin >> numerator >> denominator;
    if (denominator == 0)
        throw std::invalid_argument("Division by zero error");
    return numerator / denominator;
}

void process()
{
    // What happens if new for p1 throws an exception?
    // What happens if new for p2 throws an exception?
    // What happens if calculateDivision() throws an exception?
    int* p1 = new int;
    int* p2 = new int;
    std::cout << calculateDivision() << std::endl;
    delete p1;
    delete p2;
}

int main()
{
    try
    {
        process();
    }
    catch (const std::exception& e)
    {
        std::cout << e.what() << std::endl;
    }
    return 0;
}

Issues with the above code:

• What if new for p1 throws an exception?

  If p1 = new int; throws an exception (e.g., memory allocation failure), the control flow jumps to the catch block in main. At this point, neither p1 nor p2 have been allocated memory, so the program won't reach delete p1; and delete p2;, avoiding memory leaks. However, since neither pointer was allocated, accessing them would be undefined behavior.

• What if new for p2 throws an exception?

  If p2 = new int; throws an exception, control again jumps to the catch block in main. Here, p1 has been successfully allocated but p2 has not. This causes a memory leak for p1 because delete p1; isn't called when the exception occurs.

• What if calculateDivision() throws an exception?

  The calculateDivision() function might throw an invalid_argument exception if the user enters zero as the second value. In this case, control jumps to the catch block in main, but this results in memory leaks for both p1 and p2 becauce delete p1; and delete p2; aren't executed after the exception.

2. Memory Leaks

2.1 What are Memory Leaks and Their Dangers

1. What are memory leaks: Memory leaks occur when a program fails to release memory that is no longer in use due to oversight or errors. A memory leak doesn't mean the memory physically disappears; rather, the application loses control over allocated memory due to design flaws, resulting in wasted memory.
2. Dangers of memory leaks: Long-running programs with memory leaks suffer significant performance degradation, especially in systems like operating systems and background services. Memory leaks can cause the system to become progressively slower and eventually freeze.

void demonstrateLeaks()
{
    // 1. Memory allocated and forgotten to release
    int* p1 = (int*)malloc(sizeof(int));
    int* p2 = new int;

    // 2. Exception safety problem
    int* p3 = new int[10];

    process(); // If process() throws an exception, delete[] p3 won't be executed, causing p3 to leak.

    delete[] p3;
}

2.2 Types of Memory Leaks

In C/C++ programs, we typically concern ourselves with two types of memory leaks:

Heap Memory Leaks

Heap memory refers to blocks allocated from the heap using functions like malloc, calloc, realloc, or new. This memory must be freed using corresponding free or delete calls. If program design errors prevent this memory from being released, the space becomes unusable, creating a Heap Leak.

System Resource Leaks

These occur when programs use system resources like sockets, file descriptors, pipes, etc., without releasing them properly. This wastes system resources and can severely impact system performance and stability.

2.3 How to Detect Memory Leaks

Memory leak detection in Linux: Several C++ memory leak detection tools for Linux

Memory leak detection in Windows using third-party tools:

Visual Studio memory leaks: VLD (Visual LeakDetector) memory leak library

2.4 How to Prevent Memory Leaks

1. Good design practices and coding standards from the project's early stages, with developers remembering to release memory they allocate. Note: This is an ideal scenario. However, even with careful release practices, exceptions can still cause problems. Smart pointers provide better guarantees.
2. Adopt RAII principles or use smart pointers to manage resources.
3. Some companies use internally developed private memory management libraries that include built-in memory leak detection features.
4. When issues occur, use memory leak detection tools.

In summary: Memory leaks are common, and solutions fall into two categories:

1. Preventive measures like smart pointers.
2. Post-incident debugging using leak detection tools.
3. Smart Pointer Usage and Principles

3.1 RAII Concept

RAII (Resource Acquisition Is Initialization) is a simple technique that uses object lifetimes to control program resources (such as memory, file handles, network connections, mutexes, etc.).

Core idea:

Acquire resources during object construction, then control access to these resources throughout the object's lifetime