How can i detect the real location of memory leak in C++?

The quickest way to avoid memory leaks is to not make them in the first place. There's really no reason to manually manage memory any more, it's a bit of a mug's game.

That said there are a few of things you can try without digging into the standard library source code (nv3 knows more than I do about the structure of the runtime heap):

- Find all the places you're using new. When you find them:-

(a) work out if the object can be stack allocated instead (Java programmers in particular are buggers for newing everything and not using RAII). If you can replace them with stack objects do so!

(b) replace any raw pointers that represent ownership with std::unique_ptr, std::shared_ptr or std::vector

(c) remove all the deletes that that the compiler is now complaining about

- Instrument new and delete. Make a memory block counter class which you can declare in scopes to see if a leak potentially occurs in there. Use it in your unit tests and it'll show up if an object is leaking a contained object.

- Instrument selected class's constructors and destructor. Select them by choosing ones that are about the same size as the blocks that are being lost. Keep a running total of objects constructed and subtract the number of objects destructed. If over the run of your program you find there are excess objects constructed you can narrow the problem down to where objects of that class are newed.

- Related to the previous one if you've got a lost memory block have a look at the first word of the dumped block. If it looks like a pointer it could be the address of the class's vtable - if you have any virtual function. If you're feeling brave you might be able to correlate the address with a class using a map file (/MAP:filename on the linker command line).

- If you want to get the memory layout of a particular class or all classes in a translation unit (handy for looking at your blocks and seeing if you recognise anything in there and finding the vtable ptr) use /d1reportAllClassLayout or /dreportSingleClassLayout<class name=""></class> on the compiler command line

Er, that's about it from me, hope you sort it out soon.

The numbers in curly braces like {657} give you a hint where and when it happens. These are the allocation request numbers. So every single allocation gets a new number and by this number you can track things.

If you can reproduce the memory leak in DEBUG mode and the leaks occur always with the same request numbers you can use the following technique:

- set a breakpoint in dbgheap.c in function _heap_alloc_dbg on the line that says:

lRequest = _lRequestCurr;

Instead of looking for that file in your VC++ installation you can equally well set a breakpoint an arbitrary new statement and drill down with step-into until you arrive at function _heap_alloc_dbg. Then find the above line and set a breakpoint there.

- make this a conditional breakpoint that only triggers for the request number you are looking for

- run your program; hopefully you will land on your breakpoint

- look at the call stack and find out what actually initiated this memory allocation request

It's not a really easy technique, but very helpful in some of the hard cases.

You will have to use some profiling tool to do that. search and you will find some.

Also, check this article. it is also pretty good: Easy Detection of Memory Leaks[^]

Add the following macro into your source files, after the header includes. When in _DEBUG mode, you'll get the file and line number where the leak was allocated, reported in the output window.

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

A way that I found and use to detect memory leak. You can add following code in header file and overload global new and delete. In debug mode, you can easily identify where the memory leak happens.

struct LogInfo
{
char file[100];
int line;
};

//Create a global map : Key will be memory pointer address and value will be LogInfo object

#ifdef _DEBUG
inline void* operator new (unsigned int size, const char* file, int line)
{
void* ptr = (void*)malloc(size);
//Insert value in map
return ptr;
};

inline void operator delete(void* p)
{
//Remove value from map
free(p);
};
#endif


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


And at the end of your program you can dump your map object to identify where memory leaks has been occured.