I am trying to debug memory leaks in my game application, which consists of a executable and a dynamic-link library.

This is the code I have added following some msdn pages.

#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>

#define DEBUG_NEW new(_NORMAL_BLOCK, __FILE__, __LINE__)
#define new DEBUG_NEW

int WINAPI WinMain(HINSTANCE hInstance,
					HINSTANCE hPrevInstance,
					LPSTR lpCmdLine,
					int nCmdShow)
{
	_CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );
	_CrtSetReportMode( _CRT_ERROR, _CRTDBG_MODE_DEBUG );

	init();

	int result = loop();

	deInit();

	return result;
}

My Output looks like this though:

Detected memory leaks!
Dumping objects ->
{298045} normal block at 0x0B0AB5F0, 32 bytes long.
 Data: <Threshold: 0.800> 54 68 72 65 73 68 6F 6C 64 3A 20 30 2E 38 30 30 
{298037} normal block at 0x0B0A3B30, 8 bytes long.
 Data: <        > 10 B3 0A 0B 00 00 00 00 
{298020} normal block at 0x0B0AB0E8, 32 bytes long.
 Data: <Middle Grey: 0.1> 4D 69 64 64 6C 65 20 47 72 65 79 3A 20 30 2E 31 
{298012} normal block at 0x0B0A3C60, 8 bytes long.
 Data: <        > C0 AF 0A 0B 00 00 00 00

As far as I know I should be getting file and line numbers at this point, I did fine something earlier on gamedev that talked about this, but it didn't seem to resolve my issue and the post was quite old.

So how can I get better information about debugging these memory leaks?

Something you might want to try instead of MSVC's built in leak detector functions is Visual Leak Detector.

Tried it and I like I seem, it is still hard to understand what some of the leaks mean though.

If there's always a leak reported at the same request number (e.g. 298012), you can define a custom allocation callback function to give you more information on the leak (you register these with _CrtSetAllocHook()).

If you then break on a specific request, the call stack will show you exactly where the leak occurred.

_CrtSetAllocHook(crtDebugMemAllocHook);

I had written this tutorial a while back to help finding memory leaks.

Its still serving me well, so I think it should solve your problem as well

http://www.gamedev.net/blog/1369/entry-2253912-memory-leak-woes/

I use this type of implementation for this: http://www.flipcode.com/archives/How_To_Find_Memory_Leaks.shtml

Doesn't work on malloc etc.

It will make your code really slow, but the awesome thing is.. you can add some extra functionality:

-Record when the memory block was allocated.

-Reset you memory-track-table

-Output the table when you like to a file

-etc.