Gerenciamento de memória e a pilha de depuração

This topic applies to:

Edition	Visual Basic	C#	F#	C++	Web Developer
Express				Native only
Pro, Premium e Ultimate				Native only

Dois dos problemas mais comuns e intractable que os programadores encontrar estão substituindo o final de um vazamentos de memória e buffer alocado (falhando liberar alocações depois que eles não são mais necessários). A pilha de depuração fornece ferramentas avançadas para solucionar problemas de alocação de memória desse tipo.

Versões de depuração de funções de Heap

A depuração de versões das funções de heap chamar as versões padrão ou base usadas na versão se baseia. Quando você solicita um bloco de memória, o Gerenciador de heap de depuração aloca do heap base um bloco ligeiramente maior de memória do que a solicitou e retorna um ponteiro para a sua porção desse bloco. Por exemplo, suponha que seu aplicativo contém a chamada: malloc( 10 ). Na versão de compilação, malloc chamaria a rotina de alocação de heap base solicitando uma alocação de 10 bytes. Em uma compilação de depuração, no entanto, malloc chamaria _malloc_dbg, que chamaria a rotina de alocação de heap base solicitando uma alocação de 10 bytes mais cerca de 36 bytes de memória adicional. Todos os blocos de memória resultante na pilha de depuração são conectados em uma única lista vinculada, ordenada de acordo com quando foram alocados.

A memória adicional alocada pelas rotinas de heap de depuração é usada para obter informações de escrituração contábil, ponteiros que blocos de memória de depuração do link juntos e para os buffers pequenos em ambos os lados dos dados para capturar substitui da região alocado.

Atualmente, a estrutura de cabeçalho de bloco usada para armazenar informações de escrituração contábil da heap de depuração é declarada da seguinte maneira em que o DBGINT.Arquivo de cabeçalho H:

typedef struct _CrtMemBlockHeader
{
// Pointer to the block allocated just before this one:
    struct _CrtMemBlockHeader *pBlockHeaderNext;
// Pointer to the block allocated just after this one:
    struct _CrtMemBlockHeader *pBlockHeaderPrev;
    char *szFileName;    // File name
    int nLine;           // Line number
    size_t nDataSize;    // Size of user block
    int nBlockUse;       // Type of block
    long lRequest;       // Allocation number
// Buffer just before (lower than) the user's memory:
    unsigned char gap[nNoMansLandSize];
} _CrtMemBlockHeader;

/* In an actual memory block in the debug heap,
 * this structure is followed by:
 *   unsigned char data[nDataSize];
 *   unsigned char anotherGap[nNoMansLandSize];
 */

O NoMansLand buffers em ambos os lados da área de dados do usuário do bloco estão atualmente 4 bytes de tamanho e são preenchidos com um valor de byte conhecidos usado pelas rotinas de heap de depuração para verificar que os limites do bloco de memória do usuário não foi substituídos. A pilha de depuração também preenche novos blocos de memória com um valor conhecido. Se você optar por manter blocos liberados na lista vinculada da heap, conforme explicado abaixo, esses blocos liberados também são preenchidos com um valor conhecido. Atualmente, os valores de byte reais usados são:

• NoMansLand (0xFD)
  "nomansland" Atualmente, os buffers em ambos os lados da memória usada por um aplicativo são preenchidos com 0xFD.

• Blocos liberados (0xDD)
  Os blocos liberados mantidos não utilizados na pilha de depuração de vinculado do lista quando o _CRTDBG_DELAY_FREE_MEM_DF sinalizador é definido no momento são preenchidos com 0xDD.

• Novos objetos (0xCD)
  Novos objetos estão preenchidos com 0xCD quando eles são alocados.

Consulte também

Outros recursos

A pilha de depuração do CRT