_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.

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.

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

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