Memory leak detection in C++

Introduction

Memory leakage has always been a part of bugs in C code where a programmer allocates memory in run time (in heap) and fails to deallocate it. Most programmers use some third party software to detect memory leakage in their code, but we can also write very simple code to detect memory leakage in our program ourselves. Usually we allocate memory in C using malloc() and calloc() in run time and then we deallocate the reserved memory using free(). Sometimes we do not free the reserved memory, though, which causes memory leakage. The method below is a very simple one that helps to detect memory leakage in your program.

Using the code

Let's assume that you have allocated some memory in your code using malloc() and calloc() and haven't deallocated it. Let's say your code looks something like below:

 Collapse  |  Copy Code

test.c

#include<malloc.h>
int main() 
{
    char * ptr1 = (char *) malloc (10); 
    // allocating 10 bytes

    int * ptr2 = (int *) calloc (10, sizeof(int)); 
    // allocating 40 bytes let sizeof int =  4 bytes)

    float * ptr3 = (float *) calloc (15, sizeof(float)); 
    // allocating 60 bytes

    ............
    ............
    ............

    free(ptr2);
    return 0;
}

Steps for detecting memory leakage

I have tested the code in a Linux machine using GCC. You can test the same code in Windows, as well.

Step 1

To test for a memory leak, just add the leak_detector_c.h file to the test file and then add one line to the start of main function. Now the test code should look like below:

 Collapse  |  Copy Code

test.c

#include<malloc.h>
#include "leak_detector_c.h"

int main() 
{
    char * ptr1; 
    int * ptr2; 
    float * ptr3;

    atexit(report_mem_leak);

    ptr1 = (char *) malloc (10); 
    // allocating 10 bytes        

    ptr2 = (int *) calloc (10, sizeof(int)); 
    // allocating 40 bytes let sizeof int =  4 bytes)

    ptr3 = (float *) calloc (15, sizeof(float)); 
    // allocating 60 bytes
        
    ............
    ............
    ............

    free(ptr2);
    return 0;
}

Step 2

Now compile the code and run the program.

 Collapse  |  Copy Code

# gcc -c leak_detector_.c
# gcc -c test.c
# gcc -o memtest leak_detctor_c.o test.o
# ./memtest
# cat /home/leak_info.txt

You will get output like below:

 Collapse  |  Copy Code

Memory Leak Summary
-----------------------------------
address : 140668936
size    : 10 bytes
file    : test.c
line    : 5
-----------------------------------
address : 140669560
size    : 60 bytes
file    : test.c
line    : 7
-----------------------------------

The output shows the file name and line number that causes the memory leak. Now you can free the unallocated memory. If you have multiple source files, you can add the header file in all of the files where you want to detect possible memory leaks. Compile the program as above. Next, let's have a look into the code and see how it works.

The leak_detctor_c.h file contains some macros. The preprocessor replaces the call of malloc(), calloc() and free functions with xmalloc(), xcalloc() and xfree() respectively. While calling malloc(), our xmalloc() is called. We keep all information of the allocated memory -- such as the address, size, file name and line number -- in a linked list. When the code calls the free() function, it actually calls our xfree() and we manage to do the cleanup task. That is, we remove the entry of the allocated memory from the list and free up the allocated memory.

At the end of the program, we can get the unallocated memory references from the list. The lineatexit(report_mem_leak) registers the report_mem_leak() function to be called at the end of the program. This function writes the memory leak summary into the leak_info.txt file. You can also use #pragma exit directive instead of atexit().