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:
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:
cpp code
test.c
#include<malloc.h>
#include "leak_detector_c.h"
int main() { char * ptr1; int * ptr2; float * ptr3;
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 line atexit(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().
/* * gets the allocated memory info and adds it to a list * */ void add_mem_info (void * mem_ref, unsigned int size, const char * file, unsigned int line) { MEM_INFO mem_alloc_info;
/* fill up the structure with all info */ memset( &mem_alloc_info, 0, sizeof ( mem_alloc_info ) ); mem_alloc_info.address = mem_ref; mem_alloc_info.size = size; strncpy(mem_alloc_info.file_name, file, FILE_NAME_LENGTH); mem_alloc_info.line = line;
/* add the above info to a list */ add(mem_alloc_info); }
/* * if the allocated memory info is part of the list, removes it * */ void remove_mem_info (void * mem_ref) { unsigned short index; MEM_LEAK * leak_info = ptr_start;
/* check if allocate memory is in our list */ for(index = 0; leak_info != NULL; ++index, leak_info = leak_info->next) { if ( leak_info->mem_info.address == mem_ref ) { erase ( index ); break; } } }
/* * writes all info of the unallocated memory into a file */ void report_mem_leak(void) { unsigned short index; MEM_LEAK * leak_info;
I want to add certain point.Any suggestions are welcomed. If our program can exit from multiple locations, instead of putting a call to _CrtDumpMemoryLeaks at each possible exit,include the following call at the beginning of program:
These macros should be added after including all other header files.
3. By default, _CrtDumpMemoryLeaks dumps memory leak information to the Output window,we can reset this to a file using _CrtSetReportMode. For doing this add the following lines of code at the starting of your program. cpp code
