Foundation Class Debug Library Detects Memory Leaks

WINDOWS             | WINDOWS NT

The information in this article applies to:

• The Microsoft Foundation Classes (MFC) included with:

       - Microsoft C/C++ version 7.0
       - Microsoft Visual C++ for Windows, versions 1.0, 1.5, 1.51 and
         1.52
       - Microsoft Visual C++, 32-bit Edition, versions 1.0
  

SUMMARY

Version 2.0 of the Microsoft Foundation Classes debugging libraries provide automatic memory leak detection, a new feature that version 1.0 did not provide.

In an application developed with a Microsoft Foundation Classes version 1.0 library, the application object code typically calls the Checkpoint() function in CMemoryState objects in its InitInstance() and ExitInstance() functions. Then the application calls the CMemoryState::Difference() function to verify that no memory leaked during execution. This process is not necessary when the application uses library version 2.0.

The Microsoft Foundation Classes version 2.0 debugging libraries automatically perform memory leak detection. The detection code is in AFXMEM.CPP, which is installed in the C:\MSVC\MFC\SRC directory by default. This code detects the case in which an application dynamically allocates an object and fails to delete the object before the program terminates. The library sends a TRACE() message to the debug window stating that memory has leaked. To see these messages, TRACE() output must be enabled. Please refer to MFC Tech Note #7 for more information about enabling TRACE() output.

In version 2.0, placing a CMemoryState::Checkpoint() call in InitInstance() and ExitInstance(), as demonstrated in the code example below, does not function correctly. The code example below produces the following output:

   Memory leaked
   0 bytes in 0 Free Blocks
   0 bytes in 0 Object Blocks
   -56 bytes in -4 Non-Object Blocks

The output shown above is for an application built using the medium memory model. An application built using the large memory model will double the byte count shown in the last line of output like so:

  -112 bytes in -4 Non-Object blocks

   m_temporaryMap.InitHashTable(7); // small table for temporary map

The initial temporary maps that this function creates are destroyed in the CWinApp::OnIdle() function. In order for manual memory leak detection to work correctly, these temporary maps may be removed before your first memory checkpoint is initialized by calling DeleteTempMap() for each of the CHandleMap objects. In the code example below, removing the comment indication from the specified lines of code deletes the temporary maps and enables the manual memory leak detection code to work correctly.

As mentioned above, the Microsoft Foundation Classes debugging libraries for version 2.0 automatically detect memory leaks and the leak detection code shown below is not necessary.

More Information

The problem described in this article does not occur in the 32-bit

   versions of MFC included with Microsoft Visual C++ 2.0 or later.

Sample Code

/*
 * Compile options needed: None
 */

BOOL CTheApp::InitInstance() {

   // Remove the comment indication from the following 4 lines to
   // delete the temporary maps and allow the code to detect true
   // memory leaks.
   // CGdiObject::DeleteTempMap();
   // CDC::DeleteTempMap();
   // CMenu::DeleteTempMap();
   // CWnd::DeleteTempMap();

   oldstate.Checkpoint();

   m_pMainWnd = new CMainWindow();
   m_pMainWnd->ShowWindow( m_nCmdShow );
   m_pMainWnd->UpdateWindow();

   return TRUE;

int CTheApp::ExitInstance()

   newstate.Checkpoint();
   if (diffstate.Difference(oldstate, newstate))
      {
      TRACE("Memory leaked\n");
      diffstate.DumpStatistics();
      }
   return 0;