`_CrtSetDbgFlag`

Artikel
10/12/2023

Ruft den Status des _crtDbgFlag Flags ab oder ändert diesen, um das Zuordnungsverhalten des Debug-Heap-Managers (nur Debugversion) zu steuern.

Syntax

int _CrtSetDbgFlag(
   int newFlag
);

Parameter

newFlag
Neuer Zustand für _crtDbgFlag.

Rückgabewert

Gibt den vorherigen Zustand von _crtDbgFlag.

Hinweise

Mit _CrtSetDbgFlag der Funktion kann die Anwendung steuern, wie der Debug-Heap-Manager Speicherzuordnungen nachverfolgt, indem die Bitfelder des _crtDbgFlag Flags geändert werden. Durch Festlegen der Bitfelder kann die Anwendung den Debug-Heap-Manager anweisen, spezielle Debuggingvorgänge auszuführen. Es gibt mehrere mögliche Vorgänge:

Überprüfen auf Speicherlecks, wenn die Anwendung beendet wird, und melden Sie, falls vorhanden,
Simulieren von Bedingungen mit geringem Arbeitsspeicher durch Angabe, dass freigegebene Speicherblöcke in der verknüpften Liste des Heaps erneut ausgeführt werden sollen Standard
Überprüfen sie die Integrität des Heaps, indem Sie jeden Speicherblock bei jeder Zuordnungsanforderung prüfen.

Wenn _DEBUG sie nicht definiert ist, werden die Aufrufe _CrtSetDbgFlag während der Vorverarbeitung entfernt.

In der folgenden Tabelle sind die Bitfelder aufgeführt, für _crtDbgFlag die ihr Verhalten beschrieben wird. Da das Festlegen der Bits zu einer erhöhten Diagnoseausgabe und reduzierter Programmausführungsgeschwindigkeit führt, sind diese Bits standardmäßig nicht festgelegt (deaktiviert). Weitere Informationen zu diesen Bitfeldern finden Sie unter Heap-Statusberichtsfunktionen.

Bitfeld	Standard	Beschreibung
`_CRTDBG_ALLOC_MEM_DF`	ON	EIN: Aktiviert Debugheapzuordnungen und die Verwendung von Speicherblocktypbezeichnern wie `_CLIENT_BLOCK`. OFF: Fügen Sie der verknüpften Heap-Liste neue Zuordnungen hinzu, legen Sie jedoch den Blocktyp auf `_IGNORE_BLOCK`. Kann auch mit einem beliebigen Heap-Häufigkeitsüberprüfungsmakros kombiniert werden.
`_CRTDBG_CHECK_ALWAYS_DF`	OFF	ON: Rufen Sie `_CrtCheckMemory` bei jeder Zuordnungs- und Deallocation-Anforderung an. AUS: `_CrtCheckMemory` muss explizit aufgerufen werden. Heap-Häufigkeitsüberprüfungsmakros haben keine Auswirkungen, wenn dieses Flag festgelegt ist.
`_CRTDBG_CHECK_CRT_DF`	OFF	EIN: Schließt `_CRT_BLOCK`-Typen bei der Erkennung von Speicherverlusten und bei Vorgängen zu Speicherzustandsunterschieden ein. AUS: Der Speicher, der von der Laufzeitbibliothek intern verwendet wird, wird von diesen Vorgänge ignoriert. Kann auch mit einem beliebigen Heap-Häufigkeitsüberprüfungsmakros kombiniert werden.
`_CRTDBG_DELAY_FREE_MEM_DF`	OFF	ON: Speichern Sie freigegebene Speicherblöcke in der verknüpften Liste des Heaps, weisen Sie sie dem `_FREE_BLOCK` Typ zu, und füllen Sie sie mit dem Bytewert 0xDD. AUS: Behalten Sie keine freigegebenen Blöcke in der verknüpften Liste des Heaps bei. Kann auch mit einem beliebigen Heap-Häufigkeitsüberprüfungsmakros kombiniert werden.
`_CRTDBG_LEAK_CHECK_DF`	OFF	ON: Führen Sie die automatische Leckprüfung beim Beenden des Programms durch einen Aufruf `_CrtDumpMemoryLeaks` durch und generieren Sie einen Fehlerbericht, wenn die Anwendung nicht den gesamten zugeordneten Speicher freigeben konnte. AUS: Führen Sie beim Beenden des Programms keine Lecküberprüfung durch. Kann auch mit einem beliebigen Heap-Häufigkeitsüberprüfungsmakros kombiniert werden.

Heap-Häufigkeitsüberprüfungsmakros

Sie können angeben, wie oft die C-Laufzeitbibliothek die Überprüfung des Debug-Heaps (_CrtCheckMemory) basierend auf der Anzahl der Aufrufe an malloc, realloc, , freeund _msize.

_CrtSetDbgFlag überprüft dann die oberen 16 Bits des newFlag-Parameters auf einen Wert. Der angegebene Wert ist die Anzahl von malloc, , realloc, freeund _msize Aufrufen zwischen _CrtCheckMemory Aufrufen. Vier vordefinierte Makros werden zu diesem Zweck bereitgestellt.

Makro	Anzahl von `malloc`, , `realloc`, `free`und `_msize` Anrufen zwischen Anrufen an `_CrtCheckMemory`
`_CRTDBG_CHECK_EVERY_16_DF`	16
`_CRTDBG_CHECK_EVERY_128_DF`	128
`_CRTDBG_CHECK_EVERY_1024_DF`	1024
`_CRTDBG_CHECK_DEFAULT_DF`	0 (standardmäßig, keine Heapüberprüfungen)

Wird standardmäßig _CrtCheckMemory nicht während speichervorgängen aufgerufen. Sie können dies ändern, indem Sie die oben gezeigten Flags an _CrtSetDbgFlag().

Sie können z. B. eine Heap-Prüfung alle 16 malloc, realloc, , freeund _msize Vorgänge mit dem folgenden Code angeben:

#include <crtdbg.h>
int main( )
{
    int tmp;

    // Get the current bits
    tmp = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);

    // Clear the upper 16 bits and OR in the desired frequency
    tmp = (tmp & 0x0000FFFF) | _CRTDBG_CHECK_EVERY_16_DF;

    // Set the new bits
    _CrtSetDbgFlag(tmp);
}

Die oberen 16 Bits des newFlag Parameters werden ignoriert, wenn _CRTDBG_CHECK_ALWAYS_DF sie angegeben werden. In diesem Fall wird jedes Mal aufgerufen, _CrtCheckMemory wenn Sie anrufen malloc, , realloc, freeund _msize.

newFlag ist der neue Zustand, der auf das _crtDbgFlag Feld angewendet werden soll und eine Kombination der Werte für jedes Bitfeld ist.

So ändern Sie einen oder mehrere dieser Bitfelder und erstellen einen neuen Zustand für das Flag

Rufen Sie _CrtSetDbgFlag den newFlag_CRTDBG_REPORT_FLAG aktuellen Zustand auf, und speichern Sie den zurückgegebenen Wert in einer temporären _crtDbgFlag Variablen.
Aktivieren Sie bitweise "oder" (|) der temporären Variable mit den entsprechenden Bitmasken (dargestellt im Anwendungscode durch Manifestkonstanten).
Deaktivieren Sie die anderen Bits mit einem bitweisen "und" (&) der Variablen mit einem bitweisen "nicht" (~) der entsprechenden Bitmaske.
Rufen Sie _CrtSetDbgFlag den newFlag Wert auf, der in der temporären Variablen gespeichert ist, um den neuen Zustand für _crtDbgFlag.

Der folgende Code zeigt, wie Speichermangel simuliert wird, indem freigegebene Speicherblöcke in der verknüpften Liste des Heaps beibehalten werden, und wie verhindert wird, dass _CrtCheckMemory bei jeder Belegungsanforderung aufgerufen wird:

// Get the current state of the flag
// and store it in a temporary variable
int tmpFlag = _CrtSetDbgFlag( _CRTDBG_REPORT_FLAG );

// Turn On (OR) - Keep freed memory blocks in the
// heap's linked list and mark them as freed
tmpFlag |= _CRTDBG_DELAY_FREE_MEM_DF;

// Turn Off (AND) - prevent _CrtCheckMemory from
// being called at every allocation request
tmpFlag &= ~_CRTDBG_CHECK_ALWAYS_DF;

// Set the new state for the flag
_CrtSetDbgFlag( tmpFlag );

Eine Übersicht über die Speicherverwaltung und den Debug-Heap finden Sie unter CRT debug heap details.

Wenn Sie eine Kennzeichnung mit der _CrtSetDbgFlag Funktion deaktivieren möchten, verwenden Sie ein bitweises "und" (&) der Variablen mit der bitweisen "not" (~) der Bitmaske.

Wenn newFlag kein gültiger Wert vorhanden ist, ruft diese Funktion den ungültigen Parameterhandler auf, wie in der Parameterüberprüfung beschrieben. Wenn die weitere Ausführung zugelassen wird, legt diese Funktion errno auf EINVAL fest und gibt den vorherigen Zustand von _crtDbgFlag zurück.

Anforderungen

Routine	Erforderlicher Header
`_CrtSetDbgFlag`	`<crtdbg.h>`

Weitere Informationen zur Kompatibilität finden Sie unter Kompatibilität.

Bibliotheken

Nur Debugversionen von C-Laufzeitbibliotheken

Beispiel

// crt_crtsetdflag.c
// compile with: /c -D_DEBUG /MTd -Od -Zi -W3 /link -verbose:lib /debug

// This program concentrates on allocating and freeing memory
// blocks to test the functionality of the _crtDbgFlag flag.

#include <string.h>
#include <malloc.h>
#include <crtdbg.h>

int main( )
{
    char *p1, *p2;
    int tmpDbgFlag;

    _CrtSetReportMode( _CRT_ERROR, _CRTDBG_MODE_FILE );
    _CrtSetReportFile( _CRT_ERROR, _CRTDBG_FILE_STDERR );

    // Set the debug-heap flag to keep freed blocks in the
    // heap's linked list - This will allow us to catch any
    // inadvertent use of freed memory
    tmpDbgFlag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
    tmpDbgFlag |= _CRTDBG_DELAY_FREE_MEM_DF;
    tmpDbgFlag |= _CRTDBG_LEAK_CHECK_DF;
    _CrtSetDbgFlag(tmpDbgFlag);

    // Allocate 2 memory blocks and store a string in each
    p1 = malloc( 34 );
    p2 = malloc( 38 );
    strcpy_s( p1, 34, "p1 points to a Normal allocation block" );
    strcpy_s( p2, 38, "p2 points to a Client allocation block" );

    // Free both memory blocks
    free( p2 );
    free( p1 );

    // Set the debug-heap flag to no longer keep freed blocks in the
    // heap's linked list and turn on Debug type allocations (CLIENT)
    tmpDbgFlag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
    tmpDbgFlag |= _CRTDBG_ALLOC_MEM_DF;
    tmpDbgFlag &= ~_CRTDBG_DELAY_FREE_MEM_DF;
    _CrtSetDbgFlag(tmpDbgFlag);

    // Explicitly call _malloc_dbg to obtain the filename and
    // line number of our allocation request and also so we can
    // allocate CLIENT type blocks specifically for tracking
    p1 = _malloc_dbg( 40, _NORMAL_BLOCK, __FILE__, __LINE__ );
    p2 = _malloc_dbg( 40, _CLIENT_BLOCK, __FILE__, __LINE__ );
    strcpy_s( p1, 40, "p1 points to a Normal allocation block" );
    strcpy_s( p2, 40, "p2 points to a Client allocation block" );

    // _free_dbg must be called to free the CLIENT block
    _free_dbg( p2, _CLIENT_BLOCK );
    free( p1 );

    // Allocate p1 again and then exit - this will leave unfreed
    // memory on the heap
    p1 = malloc( 10 );
}

Siehe auch

Debugroutinen
_crtDbgFlag
_CrtCheckMemory