_CrtSetDbgFlag

Recupera o modifica lo stato del _crtDbgFlag flag per controllare il comportamento di allocazione del gestore heap di debug (solo versione di debug).

Sintassi

int _CrtSetDbgFlag(
   int newFlag
);

Parametri

newFlag
Nuovo stato per _crtDbgFlag.

Valore restituito

Restituisce lo stato precedente di _crtDbgFlag.

Osservazioni:

La _CrtSetDbgFlag funzione consente all'applicazione di controllare il modo in cui il gestore heap di debug tiene traccia delle allocazioni di memoria modificando i campi di bit del _crtDbgFlag flag. Impostando i campi di bit, l'applicazione può indicare al gestore dell'heap di debug di eseguire operazioni di debug speciali. Esistono diverse operazioni possibili:

• Verifica della presenza di perdite di memoria quando l'applicazione viene chiusa e segnala se sono presenti,
• Simulazione di condizioni di memoria insufficiente specificando che i blocchi di memoria liberati devono rimanere nell'elenco collegato dell'heap,
• Verifica dell'integrità dell'heap controllando ogni blocco di memoria in ogni richiesta di allocazione.

Quando _DEBUG non è definito, le chiamate a _CrtSetDbgFlag vengono rimosse durante la pre-elaborazione.

La tabella seguente elenca i campi di bit per _crtDbgFlag e ne descrive il comportamento. Poiché l'impostazione dei bit comporta un aumento dell'output di diagnostica e una riduzione della velocità di esecuzione del programma, questi bit non vengono impostati (disattivati) per impostazione predefinita. Per altre informazioni su questi campi di bit, vedere Funzioni di creazione di report sullo stato dell'heap.

Campo di bit	Default	Descrizione
_CRTDBG_ALLOC_MEM_DF	In...	ON: attiva le allocazioni dell'heap di debug e l'uso di identificatori del tipo di blocco di memoria, ad esempio _CLIENT_BLOCK. OFF: aggiungere nuove allocazioni all'elenco collegato dell'heap, ma impostare il tipo di blocco su _IGNORE_BLOCK. È anche possibile usare in combinazione le macro del controllo frequenza heap.
_CRTDBG_CHECK_ALWAYS_DF	OFF	ON: Chiamare _CrtCheckMemory a ogni richiesta di allocazione e deallocazione. OFF: la funzione _CrtCheckMemory deve essere chiamata in modo esplicito. Quando viene impostato questo flag, le macro del controllo frequenza heap non hanno alcun effetto.
_CRTDBG_CHECK_CRT_DF	OFF	ON: include i tipi _CRT_BLOCK nelle operazioni di rilevamento di perdite e differenze tra gli stati della memoria. OFF: la memoria usata internamente dalla libreria di runtime viene ignorata da queste operazioni. È anche possibile usare in combinazione le macro del controllo frequenza heap.
_CRTDBG_DELAY_FREE_MEM_DF	OFF	ON: mantenere i blocchi di memoria liberati nell'elenco collegato dell'heap, assegnarli al _FREE_BLOCK tipo e riempirli con il valore di byte 0xDD. OFF: non mantenere blocchi liberati nell'elenco collegato dell'heap. È anche possibile usare in combinazione le macro del controllo frequenza heap.
_CRTDBG_LEAK_CHECK_DF	OFF	ON: eseguire il controllo automatico delle perdite all'uscita del programma tramite una chiamata a _CrtDumpMemoryLeaks e generare una segnalazione errori se l'applicazione non è riuscita a liberare tutta la memoria allocata. OFF: non eseguire automaticamente il controllo delle perdite all'uscita del programma. È anche possibile usare in combinazione le macro del controllo frequenza heap.

Macro di controllo della frequenza dell'heap

È possibile specificare la frequenza con cui la libreria di runtime C esegue la convalida dell'heap di debug (_CrtCheckMemory) in base al numero di chiamate a malloc, reallocfree, e _msize.

_CrtSetDbgFlag cerca quindi un valore nei 16 bit superiori del parametro newFlag. Il valore specificato è il numero di mallocchiamate free, realloc, e _msize tra _CrtCheckMemory le chiamate. A questo scopo sono disponibili quattro macro predefinite.

Macro	Numero di mallocchiamate , realloc, freee _msize tra le chiamate a _CrtCheckMemory
_CRTDBG_CHECK_EVERY_16_DF	16
_CRTDBG_CHECK_EVERY_128_DF	128
_CRTDBG_CHECK_EVERY_1024_DF	1024
_CRTDBG_CHECK_DEFAULT_DF	0 (per impostazione predefinita, nessun controllo dell'heap)

Per impostazione predefinita, _CrtCheckMemory non viene chiamato durante le operazioni di memoria. È possibile modificarlo inviando i flag illustrati in precedenza a _CrtSetDbgFlag().

Ad esempio, è possibile specificare un controllo dell'heap ogni 16 mallocoperazioni , realloc, free, e _msize con il codice seguente:

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

I 16 bit superiori del newFlag parametro vengono ignorati quando _CRTDBG_CHECK_ALWAYS_DF viene specificato. In questo caso, _CrtCheckMemory viene chiamato ogni volta che si chiama malloc, freerealloc, e _msize.

newFlag è il nuovo stato da applicare a _crtDbgFlag e è una combinazione dei valori per ognuno dei campi di bit.

Per modificare uno più campi di bit e creare un nuovo stato per il flag

1. Chiamare _CrtSetDbgFlag con newFlag uguale a _CRTDBG_REPORT_FLAG per ottenere lo stato corrente _crtDbgFlag e archiviare il valore restituito in una variabile temporanea.

2. Attivare tutti i bit da un "or" bit per bit (|) della variabile temporanea con le maschera di bit corrispondenti (rappresentate nel codice dell'applicazione da costanti manifesto).

3. Disattivare gli altri bit con un bit per bit "and" (&) della variabile con un bit per bit "not" (~) delle maschera di bit appropriate.

4. Chiamare _CrtSetDbgFlag con newFlag uguale al valore archiviato nella variabile temporanea per impostare il nuovo stato per _crtDbgFlag.

Il codice seguente illustra come simulare condizioni di memoria insufficiente mantenendo i blocchi di memoria liberati nell'elenco collegato dell'heap e impedire che la funzione _CrtCheckMemory venga chiamata a ogni richiesta di allocazione:

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

Per una panoramica della gestione della memoria e dell'heap di debug, vedere Dettagli dell'heap di debug CRT.

Per disabilitare un flag con la _CrtSetDbgFlag funzione , usare un bit per bit "and" (&) della variabile con la "not" bit per bit (~) della maschera di bit.

Se newFlag non è un valore valido, questa funzione richiama il gestore di parametri non validi, come descritto in Convalida dei parametri. Se l'esecuzione può continuare, la funzione imposta errno su EINVAL e restituisce lo stato precedente di _crtDbgFlag.

Requisiti

Ciclo	Intestazione obbligatoria
_CrtSetDbgFlag	<crtdbg.h>

Per altre informazioni sulla compatibilità, vedere Compatibility (Compatibilità).

Librerie

Solo le versioni di debug delle librerie di runtime di C.

Esempio

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

Vedi anche

Routine di debug
_crtDbgFlag
_CrtCheckMemory