_set_new_handler

Artigo
06/09/2015

Transfere o controle para o mecanismo de tratamento de erro se o operador de new não aloca memória.

_PNH _set_new_handler(
   _PNH pNewHandler 
);

Parâmetros

pNewHandler
Ponteiro para a função de aplicativo fornecida a manipulação da memória. Um argumento de 0 faz com que o novo manipulador a ser removido.

Valor de retorno

Retorna um ponteiro para a função previous de manipulação de exceção registrada por _set_new_handler, de forma que a função anterior pode ser restaurados posteriormente. Se nenhuma função anterior foi definida, o valor de retorno pode ser usado para restaurar o comportamento padrão; esse valor pode ser NULL.

Comentários

A função C++ _set_new_handler especifica uma função de manipulação de exceções gerais que controle dos ganhos se o operador de new não aloca memória. Se new falha, o sistema de tempo de execução chama automaticamente a função manipulação de exceções gerais que foi passado como um argumento a _set_new_handler. _PNH, definido em New.h, é um ponteiro para uma função que retorna tipos int e usa um argumento do tipo size_t. Use size_t para especificar a quantidade de espaço a ser atribuído.

Não há nenhum manipulador padrão.

_set_new_handler é essencialmente um esquema de coleta de lixo. O sistema de tempo de execução repete a alocação cada vez que a função retorna um valor diferente de zero e falhará se seus função retorna 0.

Uma ocorrência da função de _set_new_handler em registros de programa a função manipulação de exceções gerais especificou na lista de argumentos no sistema de tempo de execução:

#include <new.h>
int handle_program_memory_depletion( size_t )
{
   // Your code
}
int main( void )
{
   _set_new_handler( handle_program_memory_depletion );
   int *pi = new int[BIG_NUMBER];
}

Você pode salvar o endereço de função que foi transmitido à função de _set_new_handler e restabelecê-lo posterior:

_PNH old_handler = _set_new_handler( my_handler );
   // Code that requires my_handler
   _set_new_handler( old_handler )
   // Code that requires old_handler

A função C++ _set_new_mode define o novo modo de manipulador de malloc. O novo modo de manipulador indica se, a falha, malloc é chamar a nova rotina do manipulador conforme definido por _set_new_handler. Por padrão, malloc não chama a nova rotina do manipulador em caso de falha para alocar memória. Você pode substituir esse comportamento padrão para que, quando malloc não aloca memória, malloc chama a nova rotina de manipulador da mesma forma que o operador de new faz quando falha pela mesma razão. Para substituir a opção, chame:

_set_new_mode(1)

no início do programa ou link com o Newmode.obj.

Se operator newdefinido pelo usuário for fornecido, as novas funções do manipulador não é chamado automaticamente falha.

Para obter mais informações, consulte novo e excluirna referência de linguagem C++.

Há um único manipulador de _set_new_handler para todas as dlls ou dinamicamente executáveis vinculados; mesmo se você chamar _set_new_handler seu manipulador pode ser substituído por outro ou se você estiver substituindo um manipulador definido por outro DLL ou executável.

Requisitos

Rotina	Cabeçalho necessário
_set_new_handler	<new.h>

Para obter mais informações sobre compatibilidade, consulte Compatibilidade na Introdução.

Exemplo

Neste exemplo, quando a alocação falhar, o controle é transferido para MyNewHandler. O argumento transmitido a MyNewHandler é o número de bytes necessários. O valor retornado de MyNewHandler é um sinalizador que indica se a alocação deve ser repetida: um valor diferente de zero indica que a alocação deve ser repetida, e um valor de zero indica que houve falha na alocação.

// crt_set_new_handler.cpp
// compile with: /c
#include <stdio.h>
#include <new.h>
#define BIG_NUMBER 0x1fffffff

int coalesced = 0;

int CoalesceHeap()
{
   coalesced = 1;  // Flag RecurseAlloc to stop 
   // do some work to free memory
   return 0;
}
// Define a function to be called if new fails to allocate memory.
int MyNewHandler( size_t size )
{
   printf("Allocation failed. Coalescing heap.\n");

   // Call a function to recover some heap space.
   return CoalesceHeap();
}

int RecurseAlloc() {
   int *pi = new int[BIG_NUMBER];
   if (!coalesced)
      RecurseAlloc();
   return 0;
}

int main()
{
   // Set the failure handler for new to be MyNewHandler.
   _set_new_handler( MyNewHandler );
   RecurseAlloc();
}