_CrtSetDbgFlag

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

Sintaxis

int _CrtSetDbgFlag(
   int newFlag
);

Parámetros

newFlag
Nuevo estado para _crtDbgFlag.

Valor devuelto

Devuelve el estado anterior de _crtDbgFlag.

Comentarios

La función _CrtSetDbgFlag permite que la aplicación controle cómo el administrador del montón de depuración realiza el seguimiento de asignaciones de memoria modificando los campos de bits de la marca _crtDbgFlag. Al establecer los campos de bits, la aplicación puede indicar al administrador del montón de depuración que realice operaciones de depuración especiales. Hay varias operaciones posibles:

• Comprobación de pérdidas de memoria cuando se cierra la aplicación e informa si se encuentra alguna,
• Simulación de condiciones de memoria baja especificando que los bloques de memoria liberados deben permanecer en la lista vinculada del montón,
• Para comprobar la integridad del montón, inspeccione cada bloque de memoria en cada solicitud de asignación.

Cuando _DEBUG no se define, las llamadas a _CrtSetDbgFlag se quitan durante el preprocesamiento.

En la tabla siguiente se muestran los campos de bits de _crtDbgFlag y se describe su comportamiento. Dado que el establecimiento de los bits da lugar a más resultados de diagnóstico y menor velocidad de ejecución del programa, estos bits no se establecen (están desactivados) de forma predeterminada. Para obtener más información sobre estos campos de bits, consulte Funciones de informes de estado del montón.

Campo de bit	Valor predeterminado	Descripción
_CRTDBG_ALLOC_MEM_DF	ACTIVAR	ON: habilita las asignaciones del montón de depuración y el uso de identificadores de tipos de bloques de memoria, como _CLIENT_BLOCK. OFF: agrega nuevas asignaciones a la lista vinculada del montón, pero establece el tipo del bloque en _IGNORE_BLOCK. También se puede combinar con cualquiera de las macros de comprobación de frecuencia del montón.
_CRTDBG_CHECK_ALWAYS_DF	Apagado	ON: llama a _CrtCheckMemory en cada solicitud de asignación y desasignación. OFF: se debe llamar a _CrtCheckMemory explícitamente. Las macros de comprobación de la frecuencia del montón no tienen ningún efecto cuando esta marca está establecida.
_CRTDBG_CHECK_CRT_DF	Apagado	ON: incluye tipos de _CRT_BLOCK en las operaciones de detección de pérdidas y de diferencia de estado de memoria. OFF: estas operaciones omiten la memoria que usa internamente la biblioteca en tiempo de ejecución. También se puede combinar con cualquiera de las macros de comprobación de frecuencia del montón.
_CRTDBG_DELAY_FREE_MEM_DF	Apagado	ON: mantiene los bloques de memoria liberados en la lista vinculada del montón, les asigna el tipo _FREE_BLOCK y los rellena con el valor de byte 0xDD. OFF: no mantiene los bloques liberados en la lista vinculada del montón. También se puede combinar con cualquiera de las macros de comprobación de frecuencia del montón.
_CRTDBG_LEAK_CHECK_DF	Apagado	ON: realiza la comprobación automática de pérdidas cuando se cierra el programa con una llamada a _CrtDumpMemoryLeaks y genera un informe de errores si la aplicación no ha liberado toda la memoria que había asignado. OFF: no se realiza automáticamente la comprobación de pérdidas cuando se cierra el programa. También se puede combinar con cualquiera de las macros de comprobación de frecuencia del montón.

Macros de frecuencia de comprobación del montón

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

A continuación, _CrtSetDbgFlag examina los 16 bits superiores del parámetro newFlag de un valor. El valor especificado es el número de llamadas a malloc, realloc, free y _msize entre llamadas a _CrtCheckMemory. Hay cuatro macros predefinidas para hacerlo.

Macro	Número de llamadas a malloc, realloc, free y _msize entre 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, no se comprueba el montón)

De forma predeterminada, no se llama a _CrtCheckMemory durante las operaciones de memoria. Puede cambiarlo enviando las marcas mostradas anteriormente a _CrtSetDbgFlag().

Por ejemplo, se puede especificar una comprobación del motón por cada 16 operaciones de malloc, realloc, free y _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 frequency
    tmp = (tmp & 0x0000FFFF) | _CRTDBG_CHECK_EVERY_16_DF;

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

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

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

Para cambiar estos campos de bits y crear un nuevo estado para la marca

1. Llame a _CrtSetDbgFlag con newFlag igual a _CRTDBG_REPORT_FLAG para obtener el estado actual de _crtDbgFlag y almacene el valor devuelto en una variable temporal.

2. Puede activar cualquier bit haciendo la operación bit a bit "or" (|) de la variable temporal con la máscara de bits correspondiente (representada en el código de la aplicación mediante constantes del manifiesto).

3. Desactive los demás bits mediante la operación bit a bit "and" (&) de la variable con una operación "not" (~) de las máscaras de bits adecuadas.

4. Llame a _CrtSetDbgFlag con newFlag igual al valor almacenado en la variable temporal para establecer el nuevo estado de _crtDbgFlag.

El código siguiente muestra cómo simular condiciones de memoria insuficiente conservando los bloques de memoria liberados en la lista vinculada del montón y evitar que se llame a _CrtCheckMemory 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, consulte Detalles del montón de depuración de CRT.

Para deshabilitar una marca con la función _CrtSetDbgFlag, use la operación bit a bit "and" (&) de la variable con la operación bit a bit "not" (~) de la máscara de bits.

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

Requisitos

Routine	Encabezado necesario
_CrtSetDbgFlag	<crtdbg.h>

Para obtener más información sobre compatibilidad, consulte Compatibilidad.

Bibliotecas

Solo versiones de depuración de las 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 );
}

Vea también

Rutinas de depuración
_crtDbgFlag
_CrtCheckMemory