Einleitung

Wenn es mal wieder Memory-Leaks gibt, einfach die DLL vom MemoryLeakIndicator zum Projekt linken.

In der Main bindet man MliForMain.h ein, in den Implementierungsdateien, in denen was mit new instantiiert wird, hinter allen anderen Includes nur die MilDebugNew.h.

Im jeweiligen Projekt muss die MilNewDelete.cpp mit kompiliert werden.

Motivation

Ich nutze mit Visual Studio unter Windows die crtdbg.h um Memory-Leaks angezeigt zu bekommen.

Siehe auch: https://docs.microsoft.com/de-de/visualstudio/debugger/finding-memory-leaks-using-the-crt-library?view=vs-2022

Leider werden der Dateiname und die Zeilennummer nur bei Benutzung von malloc, aber nicht bei Nutzung von new in der Ausgabe angezeigt. Bei Memory-Leaks verursacht durch ein new, werden nur die Adresse und die Daten angezeigt. Es ist zwar möglich, den Wertes aus den geschweiften Klammern der Variable _crtBreakAlloc zuzuweisen, in der Hoffnung, dass das Programm bei der Ausführung an der Stelle anhält, wo das nicht gelöschte Objekt instantiiert wird. Aber dieses ist leider nicht immer (z.B. bei DLLs) zuverlässig, da ggf. immer ein anderer Speicherort genommen wird.

Das Finden der verursachenden Anweisungen im Sourcecode gestaltet sich bisweilen schwierig. Gerne hätte hätte ich den Dateinamen und die Zeilennummer als Hinweis.

Implementierung

Wenn es mal wieder Memory-Leaks gibt, einfach die DLL vom MemoryLeakIndicator zum Projekt linken.

Zusätzlich muss im Projekt die Quellatei MilNewDelete.cpp (mit den überladenen Operator new und delete) mit kompiliert werden.

Das gilt auch für selbsterstellte DLLs, wenn dort Memory-Leaks erkannt werden sollen.

In der Main bindet man MliForMain.h ein, in den Implementierungsdateien, in denen was mit new instantiiert wird, hinter allen anderen Includes nur die MilDebugNew.h. Dieses umschließe ich mit einer Präprozessor-Anweisung wie z.B.:

#if defined _MSC_VER && defined _DEBUG_MEMORY_SPY
  ...
#endif

Zu beachten: Es ist nicht von Erfolg gekrönt, alle Sourcen von MemoryLeakIndicator in das eigene Projekt zu übernehmen, also die DLL nicht zu benutzen.

Beispiel

Im folgenden ein kleines Beispiel:

#if defined _MSC_VER && defined _DEBUG
  // detect Memory-Leaks
  #define _CRTDBG_MAP_ALLOC
  #include <crtdbg.h>
#endif

#include <iostream>
#include <string>
#include <conio.h>
#if defined _MSC_VER && defined _DEBUG_MEMORY_SPY
  #include <MliForMain.h>
#endif
//-----------------------------------------------------------------------------
class MyClass
{
  private:
    int * m_piT1;
  public:
    MyClass( int i )
    {
      m_piT1 = new int (i);
    };
    ~MyClass()
    {
      // Oh, m_piT1 forgot to delete
      //delete m_piT1;
    };
};
//-----------------------------------------------------------------------------
int main(int argc, char *argv[])
{
  #if defined _MSC_VER && defined _DEBUG
    // Displays memory leaks when there are any...
    _CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );
    // Comment out next line with number from { } -> e.g..: "{173} normal block at 0x00D01C78, 10 bytes long."
    //_crtBreakAlloc = 172;
    // Is unfortunately not always (e.g. with DLLs) reliably, because if necessary other memory location.
  #endif

  #if defined _MSC_VER && defined _DEBUG_MEMORY_SPY
    MemSpy::activateMemoryMonitoring();
  #endif

  // Examples:
  MyClass * t_pClass = new MyClass( 1 );
  //delete t_pClass;

  int * t_piLeak = new int( 2 );
  //delete t_piLeak;

  char * t_szLeak = new char[100];
  //delete[] t_szLeak;

  #if defined _MSC_VER && defined _DEBUG_MEMORY_SPY
    // Display memory leaks
    MemSpy::finishMemoryMonitoring( MemSpy::OUTPUT_TRACE | MemSpy::OUTPUT_CONSOLE );
  #endif
  std::cout << "press any key . . .";
  _getch();
  return 0;
}
//-----------------------------------------------------------------------------

Da der Funktion MemSpy::finishMemoryMonitoring(...) die Parameter MemSpy::OUTPUT_TRACE und MemSpy::OUTPUT_CONSOLE übergeben wurden, werden am Ende des Beispielprogramms die Memory-Leaks in der Konsole und im VisualStudio Ausgabefenster angezeigt.

Der Thread 15572 hat mit Code 0 (0x0) geendet.
                                                                     
  Memory leaks detected!                                            *
                                                                     
  Memory leak in 1313691209200, file D:\Projekte\C++\Src\MemoryLeakIndicator\source\main.cpp, line 45
  Memory leak in 1313691165808, file D:\Projekte\C++\Src\MemoryLeakIndicator\source\main.cpp, line 21
  Memory leak in 1313691166000, file D:\Projekte\C++\Src\MemoryLeakIndicator\source\main.cpp, line 48
  Memory leak in 1313691152224, file D:\Projekte\C++\Src\MemoryLeakIndicator\source\main.cpp, line 51
                                                                     
"MemoryLeakIndicatorDllTestd.exe" (Win32): "C:\Windows\System32\kernel.appcore.dll" geladen. 
"MemoryLeakIndicatorDllTestd.exe" (Win32): "C:\Windows\System32\msvcrt.dll" geladen. 
"MemoryLeakIndicatorDllTestd.exe" (Win32): "C:\Windows\System32\rpcrt4.dll" geladen. 
Der Thread 10624 hat mit Code 0 (0x0) geendet.
Der Thread 17076 hat mit Code 0 (0x0) geendet.
Detected memory leaks!
Dumping objects ->
{172} normal block at 0x00000131DE182F60, 100 bytes long.
 Data: <                > CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD 
{171} normal block at 0x00000131DE186530, 4 bytes long.
 Data: <    > 02 00 00 00 
{170} normal block at 0x00000131DE186470, 4 bytes long.
 Data: <    > 01 00 00 00 
{169} normal block at 0x00000131DE190DF0, 8 bytes long.
 Data: <pd  1   > 70 64 18 DE 31 01 00 00 
Object dump complete.
Das Programm "[15928] MemoryLeakIndicatorDllTestd.exe" wurde mit Code 0 (0x0) beendet.

Zu beachten: Wenn man in modernen C++ Projekten Objekte erzeugt und ggf. weiterreicht, verwendet man möglichst keine einfachen Zeiger, sonder Smart-Pointer wie std::unique_ptr oder std::shared_ptr. Es sollte sich i.d.R. nach den Vorgaben von RAII gerichtet werden.

Siehe auch: https://docs.microsoft.com/de-de/cpp/cpp/object-lifetime-and-resource-management-modern-cpp?view=msvc-170
https://docs.microsoft.com/de-de/cpp/cpp/how-to-create-and-use-shared-ptr-instances?view=msvc-170

Einschränkungen

Mir gelang es nicht, den new (std::nothrow) zu überladen. Wenn es sich um eigenen Code handelt, muss dieser new operator entweder für diesen Zweck geändert werden (ohne std::nothrow), oder es wird MilDebugNew.h nicht eingebunden.
Ab und an, gerade in Multithread-Anwendungen, werden vom MemoryLeakIndicator unechte Memory-Leaks angezeigt. Diese sind erkennbar, wenn man die Anwendung im Debug-Modus unter Verwendung von crtdbg.h laufen lässt und in der Ausgabe im VisualStudio Ausgabefenster keine zusätzlich Ausgabe gibt wie z.B.:

…
Detected memory leaks!
Dumping objects →
{172} normal block at 0x00000131DE182F60, 100 bytes long.
 Data: <                > CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD 
...

Versuche mit MinGW und GCC sind bei mir auch fehlgeschlagen; geht also nur mit VisualStudio C++. Wenn jemand bereit ist, MemoryLeakIndicator an andere Compiler anzupassen, würde ich mich freuen.