Finden von Arbeitsspeicherverlusten mit der CRT-BibliothekFind memory leaks with the CRT library

Speicherverluste gehören zu den kleinen und schwierig zu erkennenden Fehlern in C/C++-apps.Memory leaks are among the most subtle and hard-to-detect bugs in C/C++ apps. Arbeitsspeicherverluste Ergebnis nach dem Fehler um ordnungsgemäß Arbeitsspeicher freizugeben, der zuvor zugewiesen wurde.Memory leaks result from the failure to correctly deallocate memory that was previously allocated. Ein geringfügiger Speicherverlust möglicherweise zuerst nicht bemerkt werden, aber im Laufe der Zeit Symptome, die von einer schlechten Leistung bis hin zu Abstürzen bei der Ausführung der app nicht genügend Arbeitsspeicher verursachen.A small memory leak might not be noticed at first, but over time can cause symptoms ranging from poor performance to crashing when the app runs out of memory. Ein Verlust app, die verwendet, um den gesamten verfügbaren Arbeitsspeicher auf andere apps zum Absturz verursachen können, ist das Erstellen von Verwirrung in Bezug auf die app verantwortlich.A leaking app that uses up all available memory can cause other apps to crash, creating confusion as to which app is responsible. Sogar harmlose Arbeitsspeicherverluste möglicherweise andere Probleme, die korrigiert werden sollten.Even harmless memory leaks might indicate other problems that should be corrected.

Die Visual StudioVisual Studio Debugger und die C Run-Time-Laufzeitbibliothek (CRT) können Sie erkennen und Identifizieren von Arbeitsspeicherverlusten.The Visual StudioVisual Studio debugger and C Run-time Library (CRT) can help you detect and identify memory leaks.

Aktivieren der speicherverlusterkennungEnable memory leak detection

Die wichtigsten Tools zum Feststellen von Speicherverlusten der C/C++-Debugger und die C-Laufzeit-Laufzeitbibliothek (CRT) Debugheapfunktionen an.The primary tools for detecting memory leaks are the C/C++ debugger and the C Run-time Library (CRT) debug heap functions.

Um alle die Debugheapfunktionen zu aktivieren, fügen Sie die folgenden Anweisungen im C++-Programm, in der folgenden Reihenfolge aus:To enable all the debug heap functions, include the following statements in your C++ program, in the following order:

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

Durch die #define -Anweisung wird eine Basisversion der CRT-Heapfunktionen der entsprechenden Debugversion zugeordnet.The #define statement maps a base version of the CRT heap functions to the corresponding debug version. Wenn Sie sich lassen die #define -Anweisung das Speicherabbild des Arbeitsspeicherverlusts werden weniger detaillierte.If you leave out the #define statement, the memory leak dump will be less detailed.

Einschließlich "CRTDBG.h" ordnet die malloc und free Funktionen, um den entsprechenden Debugversionen _malloc_dbg und _free_dbg, Nachverfolgen von Arbeitsspeicher Zuordnung und Aufhebung der Zuordnung.Including crtdbg.h maps the malloc and free functions to their debug versions, _malloc_dbg and _free_dbg, which track memory allocation and deallocation. Diese Zuordnung findet nur in Debugbuilds mit _DEBUGstatt.This mapping occurs only in debug builds, which have _DEBUG. Releasebuilds verwenden die normalen Funktionen malloc und free .Release builds use the ordinary malloc and free functions.

Nachdem Sie die Debugheapfunktionen mit den obigen Anweisungen aktiviert haben, legen Sie einen Aufruf von _CrtDumpMemoryLeaks vor dem Endpunkt eine app zu einen Arbeitsspeicherverlust-Bericht angezeigt wird, wenn die app wird beendet.After you've enabled the debug heap functions by using the preceding statements, place a call to _CrtDumpMemoryLeaks before an app exit point to display a memory-leak report when the app exits.

_CrtDumpMemoryLeaks();

Wenn Ihre app mehrere Endpunkte verfügt, müssen Sie nicht manuell _CrtDumpMemoryLeaks an jedem Endpunkt.If your app has several exits, you don't need to manually place _CrtDumpMemoryLeaks at every exit point. Zu einen automatischen Aufruf von führen _CrtDumpMemoryLeaks zu jedem Zeitpunkt beenden, platzieren Sie einen Aufruf von _CrtSetDbgFlag am Anfang Ihrer app mit den hier gezeigten Bitfelder:To cause an automatic call to _CrtDumpMemoryLeaks at each exit point, place a call to _CrtSetDbgFlag at the beginning of your app with the bit fields shown here:

_CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );

Standardmäßig gibt _CrtDumpMemoryLeaks den Arbeitsspeicherverlust-Bericht im Bereich Debuggen des Ausgabefensters aus.By default, _CrtDumpMemoryLeaks outputs the memory-leak report to the Debug pane of the Output window. Bei Verwendung einer Bibliothek wird die Ausgabe u. U. auf einen anderen Ort zurückgesetzt.If you use a library, the library might reset the output to another location.

Können Sie _CrtSetReportMode auf den Bericht an einen anderen Speicherort umleiten oder zurück an die Ausgabe wie hier gezeigt:You can use _CrtSetReportMode to redirect the report to another location, or back to the Output window as shown here:

_CrtSetReportMode( _CRT_ERROR, _CRTDBG_MODE_DEBUG );

Interpretieren des Arbeitsspeicherverlust BerichtInterpret the memory-leak report

Wenn Ihre app definieren nicht _CRTDBG_MAP_ALLOC, _CrtDumpMemoryLeaks zeigt einen Arbeitsspeicherverlust-Bericht, die wie folgt aussieht:If your app doesn't define _CRTDBG_MAP_ALLOC, _CrtDumpMemoryLeaks displays a memory-leak report that looks like:

Detected memory leaks!
Dumping objects ->
{18} normal block at 0x00780E80, 64 bytes long.
 Data: <                > CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD
Object dump complete.

Wenn Ihre app definiert _CRTDBG_MAP_ALLOC, sieht der Arbeitsspeicherverlust Bericht:If your app defines _CRTDBG_MAP_ALLOC, the memory-leak report looks like:

Detected memory leaks!
Dumping objects ->
c:\users\username\documents\projects\leaktest\leaktest.cpp(20) : {18}
normal block at 0x00780E80, 64 bytes long.
 Data: <                > CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD
Object dump complete.

Der zweite Bericht zeigt die Anzahl von Dateinamen und Zeilennummern, in dem für der Arbeitsspeicherverlust zuerst belegt wird.The second report shows the filename and line number where the leaked memory is first allocated.

Sie definieren, ob _CRTDBG_MAP_ALLOC, im Arbeitsspeicherverlust-Bericht wird angezeigt:Whether or not you define _CRTDBG_MAP_ALLOC, the memory-leak report displays:

  • Die Speicherbelegungsnummer, handelt es sich 18 im BeispielThe memory allocation number, which is 18 in the example
  • Der Blocktyp normal im Beispiel.The block type, normal in the example.
  • Der hexadezimale Speicherbereich 0x00780E80 im Beispiel.The hexadecimal memory location, 0x00780E80 in the example.
  • Die Größe des Blocks 64 bytes im Beispiel.The size of the block, 64 bytes in the example.
  • Die ersten 16 Bytes Daten im Block im HexadezimalformatThe first 16 bytes of data in the block, in hexadecimal form.

Arbeitsspeicher-Typen sind normalen, Client, oder CRT.Memory block types are normal, client, or CRT. Ein normaler Block ist gewöhnlicher, durch das Programm belegter Speicher.A normal block is ordinary memory allocated by your program. Ein Clientblock ist ein spezieller Speicherblocktyp, der von MFC-Programmen für Objekte verwendet wird, die einen Destruktor erfordern.A client block is a special type of memory block used by MFC programs for objects that require a destructor. Durch den MFC-Operator new wird entsprechend dem zu erstellenden Objekt ein normaler Block oder ein Clientblock erstellt.The MFC new operator creates either a normal block or a client block, as appropriate for the object being created.

Ein CRT-Block wird von der CRT-Bibliothek zur eigenen Verwendung belegt.A CRT block is allocated by the CRT library for its own use. Die CRT-Bibliothek behandelt die Freigabe der speicherbelegung für diese Blöcke, damit die CRT-Blöcke nicht im Arbeitsspeicherverlust-Bericht angezeigt, es sei denn, es schwerwiegende Probleme mit der CRT-Bibliothek gibt.The CRT library handles the deallocation for these blocks, so CRT blocks won't appear in the memory-leak report unless there are serious problems with the CRT library.

Zwei weitere Speicherblocktypen werden nie in Arbeitsspeicherverlust-Berichten angezeigt.There are two other types of memory blocks that never appear in memory-leak reports. Ein freier Block Arbeitsspeicher, der freigegeben wurde damit definitionsgemäß nicht ist, ist.A free block is memory that has been released, so by definition isn't leaked. Ein ignorierter Block Arbeitsspeicher, die Ihnen explizit markiert haben, damit vom Arbeitsspeicherverlust-Bericht ausgeschlossen wird.An ignore block is memory that you've explicitly marked to exclude from the memory-leak report.

Die vorangehenden Verfahren zu identifizieren, Speicherverluste für speicherbelegung mithilfe der CRT malloc Funktion.The preceding techniques identify memory leaks for memory allocated using the standard CRT malloc function. Wenn Ihr Programm Speicher mithilfe des C++ zuordnet new -Operator, allerdings können nur sehen Sie die Anzahl von Dateinamen und Zeilennummern, in denen operator new Aufrufe _malloc_dbg im Arbeitsspeicherverlust-Bericht.If your program allocates memory using the C++ new operator, however, you may only see the filename and line number where operator new calls _malloc_dbg in the memory-leak report. Um eine nützlichere Arbeitsspeicherverlust-Bericht zu erstellen, können Sie schreiben ein Makro wie folgt auf die Zeile zu melden, die die Reservierung durchgeführt:To create a more useful memory-leak report, you can write a macro like the following to report the line that made the allocation:

#ifdef _DEBUG
    #define DBG_NEW new ( _NORMAL_BLOCK , __FILE__ , __LINE__ )
    // Replace _NORMAL_BLOCK with _CLIENT_BLOCK if you want the
    // allocations to be of _CLIENT_BLOCK type
#else
    #define DBG_NEW new
#endif

Nun können Sie ersetzen die new Operator mithilfe der DBG_NEW Makro in Ihrem Code.Now you can replace the new operator by using the DBG_NEW macro in your code. In Debugbuilds DBG_NEW verwendet eine Überladung der globalen operator new , akzeptiert zusätzliche Parameter für den Blocktyp, Datei und Zeilennummer.In debug builds, DBG_NEW uses an overload of global operator new that takes additional parameters for the block type, file, and line number. Die Überladung von new Aufrufe _malloc_dbg , die zusätzliche Informationen zu erfassen.The overload of new calls _malloc_dbg to record the extra information. Der Arbeitsspeicherverlust-Berichten zeigen die Anzahl von Dateinamen und Zeilennummern, in denen der kompromittierte Objekte reserviert wurden.The memory-leak reports show the filename and line number where the leaked objects were allocated. Releasebuilds verwenden weiterhin Standard new.Release builds still use the default new. Hier ist ein Beispiel dieser Methode:Here's an example of the technique:

// debug_new.cpp
// compile by using: cl /EHsc /W4 /D_DEBUG /MDd debug_new.cpp
#define _CRTDBG_MAP_ALLOC
#include <cstdlib>
#include <crtdbg.h>

#ifdef _DEBUG
    #define DBG_NEW new ( _NORMAL_BLOCK , __FILE__ , __LINE__ )
    // Replace _NORMAL_BLOCK with _CLIENT_BLOCK if you want the
    // allocations to be of _CLIENT_BLOCK type
#else
    #define DBG_NEW new
#endif

struct Pod {
    int x;
};

void main() {
    Pod* pPod = DBG_NEW Pod;
    pPod = DBG_NEW Pod; // Oops, leaked the original pPod!
    delete pPod;

    _CrtDumpMemoryLeaks();
}

Beim Ausführen dieses Codes in Visual Studio-debugger, den Aufruf von _CrtDumpMemoryLeaks generiert einen Bericht in der Ausgabe Fenster, das so aussieht:When you run this code in the Visual Studio debugger, the call to _CrtDumpMemoryLeaks generates a report in the Output window that looks similar to:

Detected memory leaks!
Dumping objects ->
c:\users\username\documents\projects\debug_new\debug_new.cpp(20) : {75}
 normal block at 0x0098B8C8, 4 bytes long.
 Data: <    > CD CD CD CD
Object dump complete.

Diese Ausgabe meldet, dass die kompromittierte Zuordnung in Zeile 20 des war debug_new.cpp.This output reports that the leaked allocation was on line 20 of debug_new.cpp.

Note

Nicht empfohlen, Sie erstellen ein Präprozessormakro mit dem Namen new, oder andere Programmiersprachen-Schlüsselwort.We don't recommend you create a preprocessor macro named new, or any other language keyword.

Festlegen von Breakpoints für eine SpeicherbelegungsnummerSet breakpoints on a memory allocation number

Die Speicherbelegungsnummer gibt Aufschluss darüber, wann ein Speicherblock mit Arbeitsspeicherverlust belegt wurde.The memory allocation number tells you when a leaked memory block was allocated. Ein Block mit der Speicherbelegungsnummer 18 ist z. B. der 18. Speicherblock, der während der Ausführung der app zugeordnet.A block with a memory allocation number of 18, for example, is the 18th block of memory allocated during the run of the app. Die CRT-Bericht werden alle speicherblockbelegungen während der Ausführung, einschließlich der speicherbelegungen durch die CRT-Bibliothek und anderen Bibliotheken wie MFC zählt.The CRT report counts all memory-block allocations during the run, including allocations by the CRT library and other libraries such as MFC. Deshalb keine Arbeitsspeicher Block Speicherbelegungsnummer 18 möglicherweise der 18. Speicherblock, der von Ihrem Code belegt.Therefore, memory allocation block number 18 probably isn't the 18th memory block allocated by your code.

Sie können die Speicherbelegungsnummer verwenden, um einen Haltepunkt für die Speicherbelegung festzulegen.You can use the allocation number to set a breakpoint on the memory allocation.

So legen Sie einen Haltepunkt für die Speicherbelegung im Überwachungsfenster fest:To set a memory-allocation breakpoint using the Watch window:

  1. Legen Sie einen Haltepunkt am Anfang Ihrer app, und starten Sie das Debuggen.Set a breakpoint near the start of your app, and start debugging.

  2. Wenn Sie die app am Haltepunkt angehalten wird, öffnen Sie eine Watch Fenster durch Auswahl Debuggen > Windows > Überwachen 1 (oder Überwachen 2, Überwachen 3, oder Überwachen 4).When the app pauses at the breakpoint, open a Watch window by selecting Debug > Windows > Watch 1 (or Watch 2, Watch 3, or Watch 4).

  3. In der Watch geben _crtBreakAlloc in die Namen Spalte.In the Watch window, type _crtBreakAlloc in the Name column.

    Bei Verwendung die Multithread-DLL-Version der CRT-Bibliothek (/ MD-Option), fügen Sie den Kontextoperator ein: {,,ucrtbased.dll}_crtBreakAllocIf you're using the multithreaded DLL version of the CRT library (the /MD option), add the context operator: {,,ucrtbased.dll}_crtBreakAlloc

  4. Drücken Sie die EINGABETASTE.Press Enter.

    Der Debugger wertet den Aufruf aus und gibt das Ergebnis in der Spalte Wert aus.The debugger evaluates the call and places the result in the Value column. Wenn Sie keine Haltepunkte für Speicherbelegungen festgelegt haben, lautet dieser Wert –1.This value will be -1 if you have not set any breakpoints on memory allocations.

  5. In der Wert Spalte, ersetzen Sie den Wert durch die Speicherbelegungsnummer der speicherbelegung, in denen den Debugger unterbrochen werden sollen.In the Value column, replace the value with the allocation number of the memory allocation where you want the debugger to break.

Nachdem Sie einen Haltepunkt für eine Speicherbelegungsnummer festgelegt, wird um das Debuggen fortzusetzen.After you set a breakpoint on a memory-allocation number, continue to debug. Stellen Sie sicher, dass unter gleichen Bedingungen ausgeführt werden, damit die Speicherbelegungsnummer nicht ändert.Make sure to run under the same conditions, so the memory-allocation number doesn't change. Wenn das Programm bei der angegebenen speicherbelegung unterbrochen wird, verwenden Sie die Aufrufliste Fenster und anderen Debuggerfenstern überprüfen Bedingungen, unter dem der Speicher belegt wurde.When your program breaks at the specified memory allocation, use the Call Stack window and other debugger windows to determine the conditions under which the memory was allocated. Anschließend können Sie Ausführung fortsetzen, um zu sehen, was dem Objekt geschieht und bestimmen, warum sie ordnungsgemäß freigegeben ist nicht.Then, you can continue execution to observe what happens to the object and determine why it isn't correctly deallocated.

Das Festlegen eines Datenhaltepunkts für das Objekt kann auch hilfreich sein.Setting a data breakpoint on the object might also be helpful. Weitere Informationen finden Sie unter Verwenden von Haltepunkten.For more information, see Using breakpoints.

Sie können auch Speicherbelegungshaltepunkte im Code festlegen.You can also set memory-allocation breakpoints in code. Sie können folgende Einstellungen vornehmen:You can set:

_crtBreakAlloc = 18;

oder:or:

_CrtSetBreakAlloc(18);

Speicherzustände verglichen werden sollCompare memory states

Ein weiteres Verfahren zum Ermitteln von Speicherverlusten besteht darin, zu bestimmten Zeitpunkten Momentaufnahmen von Speicherzuständen der Anwendung aufzuzeichnen.Another technique for locating memory leaks involves taking snapshots of the application's memory state at key points. Um eine Momentaufnahme des Speicherzustands an einem bestimmten Punkt in Ihrer Anwendung zu erstellen, erstellen Sie eine _CrtMemState Struktur, und übergeben es an der _CrtMemCheckpoint Funktion.To take a snapshot of the memory state at a given point in your application, create a _CrtMemState structure and pass it to the _CrtMemCheckpoint function.

_CrtMemState s1;
_CrtMemCheckpoint( &s1 );

Die _CrtMemCheckpoint Funktion, die in der Struktur mit einer Momentaufnahme des aktuellen Speicherzustands füllt.The _CrtMemCheckpoint function fills in the structure with a snapshot of the current memory state.

Um den Inhalt der Ausgabe ein _CrtMemState strukturieren, übergeben Sie die Struktur, die die _ CrtMemDumpStatistics Funktion:To output the contents of a _CrtMemState structure, pass the structure to the _ CrtMemDumpStatistics function:

_CrtMemDumpStatistics( &s1 );

_ CrtMemDumpStatistics Gibt ein Speicherabbild des Speicherzustands aus, die wie folgt aussieht:_ CrtMemDumpStatistics outputs a dump of memory state that looks like:

0 bytes in 0 Free Blocks.
0 bytes in 0 Normal Blocks.
3071 bytes in 16 CRT Blocks.
0 bytes in 0 Ignore Blocks.
0 bytes in 0 Client Blocks.
Largest number used: 3071 bytes.
Total allocations: 3764 bytes.

Um festzustellen, ob in einem Codeabschnitt ein Arbeitsspeicherverlust aufgetreten ist, können Sie Momentaufnahmen des Speicherzustands vor und nach dem Abschnitt erstellen und die beiden Zustände anschließend mithilfe von _ CrtMemDifference vergleichen:To determine whether a memory leak has occurred in a section of code, you can take snapshots of the memory state before and after the section, and then use _ CrtMemDifference to compare the two states:

_CrtMemCheckpoint( &s1 );
// memory allocations take place here
_CrtMemCheckpoint( &s2 );

if ( _CrtMemDifference( &s3, &s1, &s2) )
   _CrtMemDumpStatistics( &s3 );

_CrtMemDifference Vergleicht die Speicherzustände s1 und s2 und ein Ergebnis in zurückgibt (s3), den Unterschied zwischen s1 und s2._CrtMemDifference compares the memory states s1 and s2 and returns a result in (s3) that is the difference between s1 and s2.

Ein Verfahren zum Suchen von Arbeitsspeicherverlusten beginnt, mit dem Platzieren von _CrtMemCheckpoint Aufrufe am Anfang und Ende Ihrer-app, klicken Sie dann mit _CrtMemDifference , die Ergebnisse verglichen werden soll.One technique for finding memory leaks begins by placing _CrtMemCheckpoint calls at the beginning and end of your app, then using _CrtMemDifference to compare the results. Wenn _CrtMemDifference zeigt einem Arbeitsspeicherverlust können Sie weitere hinzufügen _CrtMemCheckpoint Aufrufe, Teilen Ihr Programm mit einer Binärsuche, bis Sie die Quelle des Verlusts isoliert haben.If _CrtMemDifference shows a memory leak, you can add more _CrtMemCheckpoint calls to divide your program using a binary search, until you've isolated the source of the leak.

Falsch positive ErgebnisseFalse positives

_CrtDumpMemoryLeaks erhalten falsche Angaben zu Speicherverlusten, wenn eine Bibliothek interne Zuordnungen als normale Blöcke anstelle von CRT-Blöcke oder Client blockiert markiert ist._CrtDumpMemoryLeaks can give false indications of memory leaks if a library marks internal allocations as normal blocks instead of CRT blocks or client blocks. In diesem Fall kann _CrtDumpMemoryLeaks den Unterschied zwischen Benutzerspeicherbelegungen und internen Bibliotheksspeicherbelegungen nicht erkennen.In that case, _CrtDumpMemoryLeaks is unable to tell the difference between user allocations and internal library allocations. Wenn die globalen Destruktoren für die Bibliotheksspeicherbelegungen nach dem Punkt ausgeführt werden, an dem _CrtDumpMemoryLeaksaufgerufen wird, wird jede interne Bibliotheksspeicherbelegung als Arbeitsspeicherverlust angezeigt.If the global destructors for the library allocations run after the point where you call _CrtDumpMemoryLeaks, every internal library allocation is reported as a memory leak. Versionen vor Visual Studio .NET kann dazu führen, dass die Standard Template Library _CrtDumpMemoryLeaks , solche falschen Positivdiagnosen.Versions of the Standard Template Library earlier than Visual Studio .NET may cause _CrtDumpMemoryLeaks to report such false positives.

Siehe auchSee also