How to Detect Memory Leaks in C++? - GeeksforGeeks (2024)

Memory leaks are a common and serious problem in C++ programming. They occur when dynamically allocated memory using operators likenewor functions likemalloc from the heap is not properly deallocated usingdeleteorfree, resulting in slow system resource utilization, degraded performance, and potential program crashes. In this article, we will understand how to detect memory leaks in C++.

Memory Leaks in C++

Before learning how to detect memory leaks let us first look at what are the major causes of memory leaks in C++. Following are the major causes of memory leaks in our programs:

• Failure to deallocate memory: When memory is allocated using the new keyword but not deallocated with the delete keyword.
• Incorrect deallocation: Using wrong deallocation operators can also lead to memory leaks such as using delete instead of delete[] to deallocate memory for dynamic arrays.
• Lost pointers: Overwriting or losing pointers to allocated memory before deallocation.
• Exception handling: Improper exception handling can lead to memory leaks if resources aren’t properly released.
• Improper use of smart pointers: Incorrect use of smart pointers, can lead to circular references that can cause memory leaks.

Detecting Memory Leaks in C++ Programs

Detecting memory leaks in C++ can be challenging due to the lack of automatic memory management. However, several strategies and tools can help detect and prevent memory leaks:

Manual Techniques

• Carefully review code to ensure everynewhas a correspondingdelete.
• Use consistent memory management patterns, such as pairing allocations and deallocations in the same scope or module.
• Implement custom memory management functions that log allocations and deallocations to track memory usage.
• Use smart pointers whenever possible.
• Properly Follow the RAII (Resource Acquisition Is Initialization) principle whenever possible in your codes.
• Implement proper exception handling to ensure resources are released.
• Conduct regular code reviews focusing on memory management.
• Write comprehensive unit tests, including tests for memory leaks.

Tools for Detecting Memory Leaks in C++

Following are the tools that can be used to detect memory leaks in C++:

• Valgrind: Valgrind is a powerful open-source tool for memory debugging and profiling. It can detect memory leaks, invalid memory accesses, and other memory-related errors. Valgrind provides detailed reports on memory leaks, including their origins and potential causes.
• AddressSanitizer: AddressSanitizer also known as (Asan) is a fast memory error detector provided by modern compilers like GCC and Clang. Youd don’t have to explicitly install this tool if you have already installed the GCC compiler in your systems.
• LeakSanitizer: Leak Sanitizer also known as (LSan) is another compiler-based tool specifically designed for detecting memory leaks. It is efficient and provides informative reports on leaked memory. Leak Sanitizer is generally included with GCC version(4.9) and above, you don’t have to specifically install it just ensure that you have a recent version of GCC.
• Visual Studio:Visual Studio provides built-in tools for detecting memory leaks. You can use the Diagnostic Tools window to take snapshots of memory usage and compare them to detect leaks.
• Deleaker:Deleaker is a memory profiler that integrates with Visual Studio and helps in detecting memory leaks by analyzing memory usage during program execution.

C++ Program to Detect Memory Leaks Using Valgrind

Let us consider the following program where we have dynamically allocated an array and did not freed it’s memory which leads to memory leak. We will detect for memory leaks in the following program with the help of valgrind.

memory_leak.cpp

// C++ program causing a memory leak#include <iostream>using namespace std;// function to allocation memory fynamically for an arrayvoid createLeak(){ int* arr = new int[10]; // Oops, forgot to delete the array!}int main(){ // calling createLeak() function createLeak(); cout << "Program finished." << endl; return 0;}

To detect memory leaks using the valgrind tool in C++ for the above program, follow the below steps:

1. Compile the program file using the below command in your terminal:

g++ -g -o memory_leak memory_leak.cpp

2. Now run the valgrind tool to detect the memory leaks using the following command:

valgrind --leak-check=full ./memory_leak

Following output will be generated by Valgrind in the terminal describing all the details about the memory leaks:

Output

==12345== Memcheck, a memory error detector
==12345== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==12345== Using Valgrind-3.14.0 and LibVEX; rerun with -h for copyright info
==12345== Command: ./leaky_program
==12345== 
==12345== 
==12345== HEAP SUMMARY:
==12345== in use at exit: 400 bytes in 1 blocks
==12345== total heap usage: 1 allocs, 0 frees, 400 bytes allocated
==12345== 
==12345== 400 bytes in 1 blocks are definitely lost in loss record 1 of 1
==12345== at 0x4C2AB80: operator new[](unsigned long) (vg_replace_malloc.c:423)
==12345== by 0x1091A9: createMemoryLeak() (leaky_program.cpp:7)
==12345== by 0x1091BF: main (leaky_program.cpp:11)
==12345== 
==12345== LEAK SUMMARY:
==12345== definitely lost: 400 bytes in 1 blocks
==12345== indirectly lost: 0 bytes in 0 blocks
==12345== possibly lost: 0 bytes in 0 blocks
==12345== still reachable: 0 bytes in 0 blocks
==12345== suppressed: 0 bytes in 0 blocks
==12345== 
==12345== For counts of detected and suppressed errors, rerun with: -v
==12345== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)