_CrtSetDbgFlag

Artigo
03/12/2013

Recupera ou modifica o estado do sinalizador de _crtDbgFlag para controlar o comportamento de alocação do gerenciador de heap de depuração (versão de depuração somente).

int _CrtSetDbgFlag(   int newFlag  );

Parâmetros

newFlag
Novo estado para _crtDbgFlag.

Valor de retorno

Retorna o estado anterior de _crtDbgFlag.

Comentários

A função de _CrtSetDbgFlag permite o aplicativo controlar como o gerenciador do heap de depuração rastreia alocações de memória alterando os campos de bits do sinalizador de _crtDbgFlag .Definindo os bits (ativação), o aplicativo pode instruir o gerenciador do heap de depuração para executar operações especiais de depuração, incluindo verificar vazamentos de memória quando o aplicativo é encerrado e relatórios se alguns são encontrados, simulando condições de memória baixa especificando que blocos de memória liberados deve permanecer na lista vinculada da heap, e em verifique a integridade da heap inspecionando cada bloco de memória em cada solicitação de alocação.Quando _DEBUG não é definido, chamadas a _CrtSetDbgFlag são removidos durante pré-processamento.

A tabela a seguir lista os campos de bits para _crtDbgFlag e descreve seu comportamento.Como definir os bits resulta na saída de diagnóstico aumentadas e a velocidade de execução do programa reduzida, esses bits não são definidos () desativado por padrão.Para obter mais informações sobre esses campos de bits, consulte Usando o heap de depuração.

Campo de bits	Padrão	Descrição
_CRTDBG_ALLOC_MEM_DF	Ativado	IN: Ativar alocações o heap de depuração e uso de identificadores em blocos de memória, como _CLIENT_BLOCK.FORA DE: Adicionar novos alocações à lista vinculada da heap, mas em blocos definido como _IGNORE_BLOCK. Também pode ser combinado com alguns dos macros de verificação de heap- frequência.
_CRTDBG_CHECK_ALWAYS_DF	Desativado	IN: Chamada _CrtCheckMemory em cada solicitação de alocação e de desalocação.FORA DE: _CrtCheckMemory deve ser chamado explicitamente. Macros de verificação de Heap- frequência não têm efeito quando este sinalizador é definido.
_CRTDBG_CHECK_CRT_DF	Desativado	IN: Inclua _CRT_BLOCK em operações de diferença de detecção de escape e de estado da memória.FORA DE: A memória usada internamente pela biblioteca em tempo de execução é ignorada por essas operações. Também pode ser combinado com alguns dos macros de verificação de heap- frequência.
_CRTDBG_DELAY_FREE_MEM_DF	Desativado	IN: Keep liberou blocos de memória na lista vinculada da heap, atribui o tipo de _FREE_BLOCK , e preenchê-las com o valor 0xDD de bytes.FORA DE: Não manter blocos liberados na lista vinculada da heap. Também pode ser combinado com alguns dos macros de verificação de heap- frequência.
_CRTDBG_LEAK_CHECK_DF	Desativado	IN: Execute o escape automática que verifica a saída de programa com uma chamada a _CrtDumpMemoryLeaks e gerar um relatório de erros se o aplicativo não liberou qualquer memória que atribuiu.FORA DE: Não executar automaticamente o escape que verifica a saída de programa. Também pode ser combinado com alguns dos macros de verificação de heap- frequência.

Macros de frequência de Heap- verificação

Você pode especificar a frequência com que a biblioteca em tempo de execução de As executa validação da heap de depuração**_CrtCheckMemory**() com base no número de chamadas a malloc, a realloc, a free, e a _msize.

_CrtSetDbgFlag inspeciona a 16 bits superior do parâmetro de newFlag para um valor.O valor especificado é o número de malloc, de realloc, de free, e de chamadas de _msize entre chamadas de _CrtCheckMemory .Quatro macros predefinidos são fornecidos para essa finalidade.

Macro	O número de malloc, o realloc, livre, e _msize chamadas entre chamadas 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 (por padrão, nenhuma verificação de heap)

Por padrão, _CrtCheckMemory é chamado uma vez que cada 1.024 vezes você chama malloc, realloc, free, e _msize.

Por exemplo, você pode especificar uma verificação de heap cada 16 malloc, realloc, free, e operações de _msize com o seguinte código:

#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 superior do parâmetro de newFlag são ignorados quando o _CRTDBG_CHECK_ALWAYS_DF é especificado.Nesse caso, _CrtCheckMemory é chamado em cada vez que você chamar malloc, realloc, free, e _msize.

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

Para alterar um ou mais desses campos de bits e criar um novo estado para o sinalizador

Chame _CrtSetDbgFlag com newFlag igual a _CRTDBG_REPORT_FLAG para obter o estado atual de _crtDbgFlag e para armazenar o valor retornado em uma variável temporário.
Ativar todos os bits por OR- ing a variável temporário com máscaras de bits correspondentes (representadas no código do aplicativo por constantes de manifesto).
Desativar os outros bits por E- ing a variável com NÃO bit a bit de bits máscaras apropriadas.
Chame _CrtSetDbgFlag com newFlag igual ao valor armazenado na variável temporário para definir o novo estado para _crtDbgFlag.

O código a seguir demonstra como simular condições de memória baixa mantendo blocos de memória liberados na lista vinculada da heap e impedir que _CrtCheckMemory é 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 o heap de depuração, consulte Gerenciamento de memória e o heap de depuração.

Para desativar um sinalizador com a função de _CrtSetDbgFlag , você deve E a variável com NÃO bit a bit de máscara de bits.

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

Requisitos

Rotina	Cabeçalho necessário
_CrtSetDbgFlag	<crtdbg.h>

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

Bibliotecas

Versões de depuração de Bibliotecas em tempo de execução de 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 );
}