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:


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:


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().

 Article by:   Rabinarayan Biswal

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:
_CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);

This statement automatically calls _CrtDumpMemoryLeaks when program exits.

2 . The macro _CRTDBG_MAP_ALLOC applies to c library functions malloc, realloc.With a little bit of extra code, we can get it to work with new/delete:

#define _CRTDBG_MAP_ALLOC

#include <iostream>
#include <crtdbg.h>

#ifdef _DEBUG
#define DEBUG_NEW new(_NORMAL_BLOCK, __FILE__, __LINE__)
#define new DEBUG_NEW
#endif

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.

HANDLE hLogFile;
hLogFile = CreateFileA("c:\\memoryLeaksDump.rtf", GENERIC_WRITE,FILE_SHARE_WRITE, NULL, CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL, NULL);

_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
_CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE);
_CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_WARN, hLogFile);
_CrtSetReportFile(_CRT_ERROR, hLogFile);
_CrtSetReportFile(_CRT_ASSERT, hLogFile);

_CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF)
thanks
Eliza
http://bit.ly/bgWpe2