Memory leak 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. And most programmers use some third party software to detect memory leak in their code.
But we can write very simple code to detect memory leak in our program.
Usually we allocate memory in C using
calloc() in run time and deallocate the reserved memory using
free(). Sometimes we don't free the reserved memory which causes memory leak.
The below method is a very simple one and helps to detect memory leak in your program.
Using the Code
Let's assume you have allocated some memory in your code using
calloc() and haven't deallocated it and your code looks like below.
char * ptr1 = (char *) malloc (10);
int * ptr2 = (int *) calloc (10, sizeof(int));
float * ptr3 = (float *) calloc (15, sizeof(float));
Steps to Detect Memory Leak
(I have tested the code in a Linux machine using GCC. You can test the same code in Windows as well.)
Now to test memory leak, just add the leak_detector_c.h file to the test file and add one line to the start of
Now the test code should look like below:
char * ptr1;
int * ptr2;
float * ptr3;
ptr1 = (char *) malloc (10);
ptr2 = (int *) calloc (10, sizeof(int));
ptr3 = (float *) calloc (15, sizeof(float));
Now compile the code and run the program:
# gcc -c leak_detector_.c
# gcc -c test.c
# gcc -o memtest leak_detctor_c.o test.o
# cat /home/leak_info.txt
Now you will get output as shown below:
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 which causes the memory leak and now you can free the unallocated memory. If you have multiple source files, you can add the header file in all the files where you want to detect possible memory leak and compile the program as above.
Now let's have a look into the code and see how it works.
The leak_detctor_c.h file contains some macros and the preprocessor replaces the call of
calloc and free functions with
xfree respectively .
xmalloc() is called and we keep all information of the allocated memory (like the address, size, file name and line number) in a linked list. While the code calls the
free() function, it actually calls our
xfree() and we manage to do the cleanup task (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 line "
atexit(report_mem_leak)" registers the
report_mem_leak() function to be called at the end of the program and this function writes the memory leak summary into the leak_info.txt file. You can also use
#pragma exit directive instead of
- 27th June, 2007: Initial post