Exportieren (0) Drucken
Alle erweitern
CAB
Uhr
EOF
Erweitern Minimieren
Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original

_CrtSetDbgFlag

Ruft oder ändert den Zustand des _crtDbgFlag-Flags ab, um das Zuordnungsverhalten des Debugheapmanagers (nur Debugversion) steuern.

int _CrtSetDbgFlag(   int newFlag  );

newFlag

Neuer Zustand für _crtDbgFlag.

Gibt den vorherigen Zustand von _crtDbgFlag zurück.

Die _CrtSetDbgFlag-Funktion ermöglicht der Anwendung, zu steuern, wie der Debugheapmanager Speicherbelegungen nachverfolgt, indem er die Bitfelder des _crtDbgFlag-Flags ändert. Indem die Bits (einschaltend) festlegen, kann die Anwendung den Debugheapmanager anweisen, spezielle Debugvorgänge, einschließlich der Überprüfung Speicherverluste auszuführen, wenn die wegen und Berichterstellung ggf. gefunden werden und Arbeitsspeichermangel, indem das simulieren freigegebene Speicherblöcke angibt, sollte in der verknüpften Liste des Heaps und im Überprüfen der Integrität des Heaps bleiben, indem sie jeden Speicherblock auf jede Zuordnungsantrag überprüft. Wenn _DEBUG nicht definiert ist, werden Aufrufe _CrtSetDbgFlag während des Präprozessorlaufs entfernt.

In der folgenden Tabelle werden die Bitfelder für _crtDbgFlag auf und beschreibt deren Verhalten. Da das Festlegen der Bits erweiterte Diagnose ausgegeben hat und reduzierte Programmausführung, diese Bits werden nicht festgelegt (standardmäßig deaktiviert) ergibt. Weitere Informationen zu diesen Bitfelder, finden Sie unter Verwenden des Debugheaps.

Bitfeld

Standardwert

Beschreibung

_CRTDBG_ALLOC_MEM_DF

ON

Klicken: Aktivieren Sie Debugheapzuordnungen und Verwendung von Arbeitsspeicherblockformatbezeichnern, wie _CLIENT_BLOCK. WEG OF: Fügen Sie neue Zuordnungen der verknüpften Liste des Heaps, aber Menge Blocktyp _IGNORE_BLOCK hinzu.

Kann mit einem der HeapHäufigkeitsüberprüfungsmakros auch kombiniert werden.

_CRTDBG_CHECK_ALWAYS_DF

OFF

Klicken: Aufruf _CrtCheckMemory auf jede Zuordnungs- und Freigabenantrag. WEG OF: _CrtCheckMemory muss explizit aufgerufen werden.

Heap-Häufigkeitsüberprüfungsmakros haben keine Auswirkungen, wenn dieses Flag festgelegt ist.

_CRTDBG_CHECK_CRT_DF

OFF

Klicken: Zu _CRT_BLOCK-Typen Speicherverluste und Speicherzustandsunterschiedvorgänge ein. WEG OF: Der Speicher, der von der Laufzeitbibliothek intern verwendet wird, wird durch diese Operationen ignoriert.

Kann mit einem der HeapHäufigkeitsüberprüfungsmakros auch kombiniert werden.

_CRTDBG_DELAY_FREE_MEM_DF

OFF

Klicken: Keep gab Speicherblöcke in der verknüpften Liste des Heaps frei, weist ihnen den _FREE_BLOCK-Typ zu und füllt sie mit dem Bytewert 0xDD aus. WEG OF: Halten Sie freigegebene Blöcke nicht in der verknüpften Liste des Heaps.

Kann mit einem der HeapHäufigkeitsüberprüfungsmakros auch kombiniert werden.

_CRTDBG_LEAK_CHECK_DF

OFF

Klicken: Führen Sie die automatische Verlustüberprüfung an der Programmabbruch aufgrund durch einen Aufruf _CrtDumpMemoryLeaks aus und generieren Sie einen Fehlerbericht, wenn die Anwendung den gesamten Arbeitsspeicher freigeben konnte, den sie zugeordnet sind. WEG OF: Nicht automatisch führen Sie Verlustüberprüfung an der Programmabbruch aufgrund aus.

Kann mit einem der HeapHäufigkeitsüberprüfungsmakros auch kombiniert werden.

Heap-Überprüfungs-Häufigkeits-Makros

Sie können angeben, wieoft die C-Laufzeitbibliothek Validierung des Debugheaps (_CrtCheckMemory) anhand der Anzahl der Aufrufe malloc, zu realloc, zu free und zu _msize ausführt.

_CrtSetDbgFlag überprüft dann die oberen 16 Bits newFlag des Parameters für einen Wert. Der angegebene Wert ist die Anzahl der malloc, realloc, free und _msize Aufrufe zwischen _CrtCheckMemory Aufrufen. Vier vordefinierte Makros werden zu diesem Zweck bereitgestellt.

Makro

Zahl malloc, das realloc kostenloses, und _msize Aufrufe zwischen Aufrufen von _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)

Standardmäßig wird _CrtCheckMemory aufgerufen, sobald jedes 1.024 Sie malloc, realloc, free und _msize aufrufen.

Beispielsweise können Sie eine Heapüberprüfung angeben jeweils 16 malloc, realloc, free und _msize Vorgänge mit dem folgenden Code:

#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 freqency
tmp = (tmp & 0x0000FFFF) | _CRTDBG_CHECK_EVERY_16_DF;

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

Die oberen 16 Bits newFlag des Parameters werden ignoriert, wenn _CRTDBG_CHECK_ALWAYS_DF angegeben wird. In diesem Fall wird _CrtCheckMemory aufgerufen, wenn Sie malloc, realloc, free und _msize aufrufen.

newFlag ist der neue auf _crtDbgFlag anzuwenden, Zustand, und ist eine Kombination der Werte für jedes der Bitfelder.

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

  1. Rufen Sie _CrtSetDbgFlag mit newFlag gleich _CRTDBG_REPORT_FLAG auf, erhält der aktuelle _crtDbgFlag Zustand und den Rückgabewert in einer temporären Variablen zu speichern.

  2. Beenden Sie alle Bits durch OR- Verknüpfung der temporären Variable mit den entsprechenden Bitmasken ein (im Anwendungscode durch Manifestkonstanten dargestellt).

  3. Stellen Sie die anderen Bits durch UND- Verknüpfung die Variable mit bitweisen NOT der entsprechenden Bitmasken ab.

  4. Rufen Sie _CrtSetDbgFlag mit newFlag gleich dem Wert auf, der in der temporären Variablen gespeichert wurde, um den neuen Zustand für _crtDbgFlag festzulegen.

Der folgende Code zeigt, wie Arbeitsspeichermangel simuliert, indem er freigegebene Speicherblöcke in der verknüpften Liste des Heaps enthält und verhindert, dass _CrtCheckMemory auf jede Zuordnungsantrag aufgerufen:

// 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 der Speicherverwaltung und des Debugheaps, finden Sie unter Speicherverwaltung und der Debugheap.

Um ein Flag mit der _CrtSetDbgFlag-Funktion zu deaktivieren, sollten Sie UND die Variable mit bitweisen NOT der Bitmaske.

Wenn newFlag kein gültiger - Wert ist, Aufrufe dieser Funktion der ungültige Parameterhandler, wie in Parametervalidierung beschrieben. Wenn die Ausführung zulässig ist, um fortzufahren, Sätze errno dieser Funktion zu EINVAL und Rückgabe von der vorherigen Zustand von _crtDbgFlag.

Routine

Erforderlicher Header

_CrtSetDbgFlag

<crtdbg.h>

Weitere Informationen zur Kompatibilität finden Sie in der Einführung unter Kompatibilität.

Bibliotheken

Debugversionen von nur C-Laufzeitbibliotheken.

// 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 );
}

Nicht zutreffend. Um die Standard-C-Funktion aufzurufen, verwenden Sie PInvoke. Weitere Informationen finden Sie unter Beispiele für Plattformaufrufe.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2015 Microsoft