Understanding Memory Leaks in C++

Memory leaks occur when a program allocates memory on the heap but fails to release it after use. This can lead to reduced performance or even application crashes. In C++, dynamic memory allocation is commonly done using new and delete. If the allocated memory is not properly managed, it results in memory leaks. Below are three practical examples that illustrate common scenarios leading to memory leaks when using dynamic memory allocation in C++.

Example 1: Simple Object Creation Without Deletion

In this example, we demonstrate a straightforward case where an object is created dynamically but never deleted, leading to a memory leak.

When developing applications, you might create objects to handle specific tasks. If you forget to free the allocated memory, it will remain allocated until the program terminates, causing a memory leak.

#include <iostream>

class MyClass {
public:
    MyClass() { std::cout << "MyClass created!" << std::endl; }
    ~MyClass() { std::cout << "MyClass destroyed!" << std::endl; }
};

int main() {
    MyClass* obj = new MyClass(); // Memory allocated
    // No delete obj; here, causing a memory leak.
    return 0; // Memory leak occurs when the program exits.
}

Notes: Ensure that every new has a corresponding delete to prevent memory leaks. In this example, the destructor of MyClass is never called because the object is not deleted.

Example 2: Memory Leak in a Loop

This example illustrates how a memory leak can occur within a loop, where new objects are continuously created without being released.

When processing data in a loop, it’s crucial to manage memory properly. Failing to delete each allocated object in each iteration will lead to cumulative memory usage, eventually exhausting available memory.

#include <iostream>
#include <vector>

class Data {
public:
    Data() { std::cout << "Data object created!" << std::endl; }
    ~Data() { std::cout << "Data object destroyed!" << std::endl; }
};

int main() {
    std::vector<Data*> dataList;
    for (int i = 0; i < 10; ++i) {
        Data* data = new Data(); // Memory allocated
        dataList.push_back(data);
        // No delete data; here, causing memory leaks.
    }
    return 0; // Memory leaks occur for all allocated Data objects.
}

Notes: To mitigate this leak, ensure that you delete each object after its use. A best practice is to use smart pointers, which automatically manage memory.

Example 3: Incorrect Exception Handling

In this example, we explore how improper exception handling can lead to memory leaks when an exception is thrown.

When writing robust applications, particularly those that involve file I/O or network operations, it’s important to handle exceptions correctly. Failing to free dynamically allocated memory in the event of an exception can lead to memory leaks.

#include <iostream>
#include <stdexcept>

class Resource {
public:
    Resource() { std::cout << "Resource created!" << std::endl; }
    ~Resource() { std::cout << "Resource destroyed!" << std::endl; }
};

void processResource() {
    Resource* res = new Resource(); // Memory allocated
    throw std::runtime_error("An error occurred!"); // Exception thrown
    delete res; // This line is never reached, causing a memory leak.
}

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

Notes: To avoid this situation, consider using RAII (Resource Acquisition Is Initialization) principles or smart pointers, which automatically manage memory and ensure proper cleanup, even in the event of exceptions.