_CrtSetDbgFlag

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.

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.

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

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

2. 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).

3. Desactive los otros bits por AND- ing la variable con NOT bit a bit de máscaras de bits adecuadas.

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

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

Equivalente en .NET Framework

No es aplicable Para llamar a la función estándar de C, utilice PInvoke. Para obtener más información, vea La invocación de plataforma ejemplos.

Vea también

Referencia

Rutinas de depuración

_crtDbgFlag

_CrtCheckMemory

Conceptos

Funciones que indican el estado del montón