_CrtSetDbgFlag

Recupera ou modifica o estado do _crtDbgFlag sinalizar para controle o comportamento de alocação do Gerenciador de heap de depurar (somente versão de depurar).

int _CrtSetDbgFlag( 
   int newFlag 
);

Parâmetros

• newFlag
  Novo estado para _crtDbgFlag.

Valor de retorno

Retorna o estado anterior do _crtDbgFlag.

Comentários

The _CrtSetDbgFlag função permite que o aplicativo controlar como o Gerenciador de heap de depurar rastreia as alocações de memória modificando campos de bit a _crtDbgFlag sinalizar.Por configuração bits (ligar), o aplicativo pode instruir o Gerenciador de heap de depurar para executar operações de depurar especiais, incluindo verificação de vazamentos de memória quando o aplicativo termina e emissão de relatórios se encontrar, simulando condições de pouca memória especificando que os blocos de memória liberada devem permanecer na lista vinculada da heap e verificar a integridade da heap inspecionando cada bloco de memória por cada solicitação de alocação.Quando _DEBUG não estiver definido, chamadas de _CrtSetDbgFlag serão removidos durante a pré-processamento.

A tabela a seguir lista os campos de bit de _crtDbgFlag e descreve seu comportamento.Como conjunto os resultados de bits nas maiores diagnóstico saída e velocidade de execução de programa reduzido, esses bits não estão definidas (desativados) por padrão.Para obter mais informações sobre esses campos de bit, consulte Usando a pilha de depurar.

Macros de freqüência de verificação de heap

Você pode especificar a freqüência com que a biblioteca de time de execução C executa a validação da pilha de depurar (_CrtCheckMemory) com base no número de chamadas para malloc, realloc, disponível, and _msize.

_CrtSetDbgFlag em seguida, inspecione os 16 bits superiores das newFlag parâmetro para um valor. O valor especificado são o número de malloc, realloc, disponível, and _msize chamadas entre _CrtCheckMemory chamadas. Quatro macros predefinidas são fornecidas para essa finalidade.

Por padrão, _CrtCheckMemory é telefonar ed depois que cada 1.024 vezes você telefonar malloc, realloc, disponível, and _msize.

Por exemplo, você pode especificar uma verificação de heap cada 16 malloc, realloc, disponível, and _msize operações com o código a seguir:

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

Os 16 bits superiores a newFlag parâmetro são ignorados quando _CRTDBG_CHECK_ALWAYS_DF é especificado. Nesse caso, _CrtCheckMemory é chamado sempre que você chamar malloc, realloc, disponível, and _msize.

newFlag é o novo estado para aplicar a _crtDbgFlag e é uma combinação dos valores para cada um dos campos de bit.

Para alterar uma ou mais desses campos de bit e criar um novo estado para o sinalizar

1. De telefonar**_CrtSetDbgFlag** com newFlag igual a _CRTDBG_REPORT_FLAG Para obter o corrente _crtDbgFlag estado e armazenou o valor retornado em uma variável temporária.

2. Ative os bits por OR-ing variável temporária com as máscaras de bits correspondentes (representadas por constantes manifesto no código do aplicativo).

3. Desativar os outros bits E-ing a variável com um bit a bit NÃO bitmasks apropriado.

4. De telefonar**_CrtSetDbgFlag** com newFlag igual ao valor armazenado na variável temporária para conjunto o novo estado para _crtDbgFlag.

O código a seguir demonstra como simular memória baixa condições mantendo liberado blocos de memória lista vinculada do heap de e evitar _CrtCheckMemory de que está sendo chamado em cada solicitação de alocação:

// 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 obter uma visão geral de gerenciamento de memória e a pilha de depurar, consulte A pilha de depurar e gerenciamento de memória.

Para desabilitar um sinalizar com o _CrtSetDbgFlag função, você deve E a variável com o bit a bit NÃO de bitmask.

If newFlag não é um valor válido, essa função chama o manipulador de parâmetro inválido, conforme descrito em Validação de parâmetro. Se a execução for permitida para continuar, essa função define errno para EINVAL e retorna o estado anterior do _crtDbgFlag.

Requisitos

Para obter mais informações de compatibilidade, consulte Compatibilidade na introdução.

Bibliotecas

Versões de depurar de Bibliotecas de time de execução c somente.

Exemplo

// 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 do NET Framework

Não aplicável. Para telefonar a função C padrão, use PInvoke. Para obter mais informações, consulte Exemplos de invocação de plataforma.

Consulte também

Conceitos

Funções de Relatórioss de estado de heap

Referência

Rotinas de depurar

_crtDbgFlag

_CrtCheckMemory