_CrtSetDbgFlag

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

int _CrtSetDbgFlag( 
   int newFlag 
);

Parametri

• newFlag
  Nuovo stato per _crtDbgFlag.

Valore restituito

Restituisce lo stato precedente _crtDbgFlag.

Note

La funzione di _CrtSetDbgFlag modo l'applicazione controllare come gestore dell'heap di debug tiene traccia delle allocazioni di memoria modificando i campi di bit di flag _crtDbgFlag.Impostando i bit (che accendono), l'applicazione può indicare all'amministratore dell'heap di debug eseguire operazioni di debug speciali, tra cui verificare la presenza di eventuali perdite di memoria al termine e creazione di applicazioni si ne vengono trovate, simulanti condizioni di memoria insufficiente specificando quella blocchi di memoria liberati deve rimanere nell'elenco collegato dell'heap e nel verificare l'integrità dell'heap controllando ciascun blocco di memoria a ogni richiesta di allocazione.Quando _DEBUG non è definito, le chiamate a _CrtSetDbgFlag vengono rimosse durante la pre-elaborazione.

Nella tabella seguente sono elencati i campi di bit per bit _crtDbgFlag e viene descritto il comportamento.Poiché impostare i bit produce l'output elevato di diagnostica e la velocità di esecuzione del programma una, questi bit non sono impostati (disattivato) per impostazione predefinita.Per ulteriori informazioni su questi campi di bit, vedere Utilizzo dell'heap di debug.

Campo di bit	Predefinito	Descrizione
_CRTDBG_ALLOC_MEM_DF	ON	SU: Abilitazione delle allocazioni di memoria heap di debug e l'utilizzo di identificatori a blocchi di memoria, come _CLIENT_BLOCK.FUORI FROM: Aggiungere nuove allocazioni all'elenco collegato dell'heap, ma il tipo di blocco impostato su _IGNORE_BLOCK. Può inoltre essere combinate con le macro del controllo di heap- frequenza.
_CRTDBG_CHECK_ALWAYS_DF	OFF	SU: Chiamata _CrtCheckMemory a ogni richiesta di allocazione e disallocazione.FUORI FROM: _CrtCheckMemory deve essere chiamato in modo esplicito. Le macro del controllo di Heap- frequenza non hanno effetto quando il flag è impostato.
_CRTDBG_CHECK_CRT_DF	OFF	SU: Importare _CRT_BLOCK nelle operazioni di stato a differenza della memoria e del rilevamento di perdite.FUORI FROM: La memoria utilizzata internamente dalla libreria di runtime viene ignorata da queste operazioni. Può inoltre essere combinate con le macro del controllo di heap- frequenza.
_CRTDBG_DELAY_FREE_MEM_DF	OFF	SU: Keep ha liberato i blocchi di memoria nell'elenco collegato dell'heap, assegna loro il tipo _FREE_BLOCK e li inserisce di valore byte 0xDD.FUORI FROM: Non memorizzare i blocchi liberati nell'elenco collegato dell'heap. Può inoltre essere combinate con le macro del controllo di heap- frequenza.
_CRTDBG_LEAK_CHECK_DF	OFF	SU: Eseguire una perdita automatica che controlla al termine del programma con una chiamata a _CrtDumpMemoryLeaks e generare una segnalazione errori se l'applicazione non riuscita liberato tutta la memoria che ha allocato.FUORI FROM: Non eseguire automaticamente la perdita che controlla al termine del programma. Può inoltre essere combinate con le macro del controllo di heap- frequenza.

Macro di frequenza di Heap- controllo

È possibile specificare la frequenza la libreria di runtime C eseguire la convalida dell'heap di debug (_CrtCheckMemory) in base al numero di chiamate a malloc, a realloc, su freee a _msize.

_CrtSetDbgFlag quindi cerca i 16 bit superiore del parametro di newFlag per un valore.Il valore indicato è il numero di malloc, di realloc, freee le chiamate di _msize tra le chiamate di _CrtCheckMemory.Quattro macro predefinite vengono fornite a questo scopo.

Macro	Il numero di creazione, realloc, liberi e _msize le chiamate 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, non controlli dell'heap)

Per impostazione predefinita, _CrtCheckMemory viene chiamato una volta ogni 1.024 volte chiamate malloc, realloc, freee _msize.

Ad esempio, è possibile specificare un controllo dell'heap ogni 16 malloc, realloc, freee operazioni di _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 freqency
tmp = (tmp & 0x0000FFFF) | _CRTDBG_CHECK_EVERY_16_DF;

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

I 16 bit superiore del parametro di newFlag vengono ignorati quando il _CRTDBG_CHECK_ALWAYS_DF è specificato.In questo caso, _CrtCheckMemory viene chiamato ogni volta che viene chiamato malloc, realloc, freee _msize.

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

Per modificare uno o più di questi 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 memorizzare il valore restituito in una variabile temporanea.

2. Attivare tutti i bit da OR- effettuando la variabile temporanea e le corrispondenti maschere di bit (rappresentate nel codice dell'applicazione da costanti manifesto).

3. Disattivare gli altri bit da AND- effettuando la variabile con NOT bit per bit delle maschere di bit appropriate.

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

Il codice seguente viene illustrato come simulare condizioni di memoria insufficiente mantenendo i blocchi di memoria liberati nell'elenco collegato dell'heap e impedire _CrtCheckMemory venga chiamato 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 di gestione della memoria e heap di debug, vedere Gestione della memoria e heap di debug.

Per disabilitare un flag con la funzione di _CrtSetDbgFlag, è necessario AND la variabile con NOT bit per bit maschera di bit.

Se newFlag non è un valore valido, chiamare questa funzione del gestore non valido di parametro, come descritto in Convalida dei parametri.Se l'esecuzione è consentita per continuare, set errno di questa funzione a EINVAL e restituisce lo stato precedente di _crtDbgFlag.

Requisiti

Routine	Intestazione obbligatoria
_CrtSetDbgFlag	<crtdbg.h>

Per ulteriori informazioni sulla compatibilità, vedere Compatibilità nell'introduzione.

Librerie

Solo versioni di debug di Librerie di runtime 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 );
}

Equivalente .NET Framework

Non applicabile. Per chiamare la funzione standard C, utilizzare PInvoke. Per ulteriori informazioni, vedere Esempi di Invocazione della Piattaforma.

Vedere anche

Riferimenti

Procedura di debug

_crtDbgFlag

_CrtCheckMemory

Concetti

Funzioni per la creazione di rapporti sullo stato dello heap