_CrtSetDbgFlag

Artículo
04/10/2013

Recupera o modifican el estado del indicador _crtDbgFlag para controlar el comportamiento de la asignación del administrador del montón de depuración (versión de depuración solo).

int _CrtSetDbgFlag( 
   int newFlag 
);

Parámetros

newFlag
Nuevo estado _crtDbgFlag.

Valor devuelto

Devuelve el estado anterior _crtDbgFlag.

Comentarios

La función de _CrtSetDbgFlag permite a la aplicación para controlar cómo el administrador del montón de depuración siguiente asignaciones de memoria modificando los campos de bit de marcador _crtDbgFlag.Establecer los bits (que giran en), la aplicación puede indicar al administrador del montón de depuración para realizar operaciones especiales de depuración, como comprobar si existen pérdidas de memoria cuando se cierra la aplicación e informes de errores si se encuentren, simular problemas de memoria insuficiente especificando que los bloques de memoria liberada debe permanecer en la lista vinculada del montón, y comprobar la integridad de la pila inspeccionando cada bloque de memoria de cada solicitud de asignación.Cuando _DEBUG no está definido, las llamadas a _CrtSetDbgFlag se quitan durante el preprocesamiento.

La tabla siguiente se muestran los campos de bits para _crtDbgFlag y describe su comportamiento.Dado que establecer los bits da lugar a diagnóstico más generó y reduce la velocidad de ejecución del programa, estos bits no se establece (desactivado) de forma predeterminada.Para obtener más información sobre estos campos de bits, vea Uso del montón de depuración.

Campo de bit	Default	Descripción
_CRTDBG_ALLOC_MEM_DF	ON	ON: Habilite las asignaciones del montón de depuración y el uso de identificadores en bloques de memoria, como _CLIENT_BLOCK.OFF: Agregue nuevas asignaciones a la lista vinculada del montón, pero en bloques establecida en _IGNORE_BLOCK. También puede combinarse con macros cualquiera de la comprobación de la pila- frecuencia.
_CRTDBG_CHECK_ALWAYS_DF	OFF	ON: Llamada _CrtCheckMemory en cada solicitud de asignación y la desasignación.OFF: _CrtCheckMemory se debe denominar explícitamente. Las macros de comprobación de la Pila- frecuencia no tienen ningún efecto cuando se establece este marcador.
_CRTDBG_CHECK_CRT_DF	OFF	ON: Include de _CRT_BLOCK de tipos detección y memoria de escape en estado operaciones de diferencia.OFF: Memoria utilizada internamente por la biblioteca en tiempo de ejecución pasa por alto estas operaciones. También puede combinarse con macros cualquiera de la comprobación de la pila- frecuencia.
_CRTDBG_DELAY_FREE_MEM_DF	OFF	ON: Keep liberaba los bloques de memoria de la lista vinculada del montón, los asignar el tipo _FREE_BLOCK, y se rellena con el valor 0xDD byte.OFF: No mantener los bloques liberados en la lista vinculada del montón. También puede combinarse con macros cualquiera de la comprobación de la pila- frecuencia.
_CRTDBG_LEAK_CHECK_DF	OFF	ON: Realice el escape automático que protege en la salida del programa con una llamada a _CrtDumpMemoryLeaks y generar un informe de error si la aplicación podría no para liberar toda la memoria asignada.OFF: Automáticamente no realice el escape que protege en la salida del programa. También puede combinarse con macros cualquiera de la comprobación de la pila- frecuencia.

Macros de la frecuencia de Pila-CHECK

Puede especificar la frecuencia con la biblioteca en tiempo de ejecución de C realiza la validación del montón de depuración (_CrtCheckMemory) según el número de llamadas a malloc, a realloc, a free y, a _msize.

_CrtSetDbgFlag continuación examina los 16 bits superiores del parámetro de newFlag por un valor.El valor especificado es el número de malloc, de realloc, free, y las llamadas de _msize entre las llamadas de _CrtCheckMemory.Cuatro macros predefinidas se proporcionan con este fin.

Macro	El número de malloc, el realloc, libres, y _msize llamadas entre las llamadas 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 (de forma predeterminada, las comprobaciones de la pila)

De forma predeterminada, se denomina _CrtCheckMemory una vez cada 1.024 veces se denomina malloc, realloc, free, y _msize.

Por ejemplo, puede especificar una pila comprueba cada 16 malloc, realloc, free, y las operaciones de _msize con el código siguiente:

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

Los 16 bits superiores del parámetro de newFlag se omiten cuando se especifica el _CRTDBG_CHECK_ALWAYS_DF.En este caso, se denomina _CrtCheckMemory cada vez que se llama a malloc, realloc, free, y _msize.

newFlag es el nuevo estado a aplicar a _crtDbgFlag y es una combinación de los valores de cada uno de los campos de bits.

Para cambiar uno o más de estos campos de bit y crear un nuevo estado para el marcador

Llame a _CrtSetDbgFlag con newFlag igual a _CRTDBG_REPORT_FLAG para obtener el estado actual _crtDbgFlag y almacenar el valor devuelto en una variable temporal.
Puede activar cualquier bit por OR- ing la variable temporal con la máscara de bits correspondientes (representada en el código de aplicación por constantes de manifiesto).
Desactive los otros bits por AND- ing la variable con NOT bit a bit de máscaras de bits adecuadas.
Llamada _CrtSetDbgFlag con newFlag igual al valor almacenado en la variable temporal para establecer el nuevo estado _crtDbgFlag.

El código siguiente muestra cómo simular problemas de memoria insuficiente conservando los bloques de memoria liberada en la lista vinculada del montón y evitar que _CrtCheckMemory se llamará en cada solicitud de asignación:

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

Para obtener información general sobre la administración de memoria y el montón de depuración, vea Administración de memoria y el montón de depuración.

Para deshabilitar un indicador a la función de _CrtSetDbgFlag, debe AND la variable con NOT bit a bit de la máscara de bits.

Si newFlag no es un valor válido, esta función invoca el controlador no válido de parámetro, tal y como se describe en Validación de parámetros.Si la ejecución puede continuar, conjuntos errno de esta función a EINVAL y devuelven el estado anterior de _crtDbgFlag.

Requisitos

Rutina	Encabezado necesario
_CrtSetDbgFlag	<crtdbg.h>

Para obtener más información de compatibilidad, vea Compatibilidad en la Introducción.

Bibliotecas

Versiones de depuración de Bibliotecas en tiempo de ejecución de C.

Ejemplo

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