_set_new_handler

Artigo
02/25/2013

Transfere o controle para o seu mecanismo de tratamento de erros se a new operador Falha ao alocar a memória.

_PNH _set_new_handler(
   _PNH pNewHandler 
);

Parâmetros

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

Valor de retorno

Retorna um ponteiro para a função registrada de manipulação de exceção anterior _set_new_handler, de modo que a função anterior pode ser restaurada posteriormente.Se nenhuma função anterior tiver sido definida, o valor de retorno pode ser usado para restaurar o comportamento padrão; Esse valor pode ser NULL.

Comentários

O C++ _set_new_handler função especifica uma função de manipulação de exceção que ganha o controle se o new operador Falha ao alocar a memória.Se new falhar, o sistema de tempo de execução automaticamente chama a função de manipulação de exceção que foi passada como um argumento para _set_new_handler._PNH, definido em New.h, é um ponteiro para uma função que retorna o tipo de int e leva um argumento do tipo size_t.Use size_t para especificar a quantidade de espaço a ser alocada.

Não há nenhum manipulador padrão.

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

Uma ocorrência de _set_new_handler função em um programa registra a função de manipulação de exceção especificada na lista do argumento com o 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 da função que foi passado pela última vez para o _set_new_handler de função e reabilitá-la mais tarde:

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

O C++ _set_new_mode função define o novo modo de manipulador para malloc.O novo modo de manipulador indica se deve, em caso de falha, malloc é chamar a rotina manipuladora de novo conforme definido por _set_new_handler.Por padrão, malloc não chama a rotina manipuladora de novo em caso de falha ao alocar memória.Você pode substituir esse comportamento padrão para que, quando malloc Falha ao alocar memória, malloc chama a rotina manipuladora de novo na mesma maneira que o new operador oferece quando falhar pelo mesmo motivo.Para substituir o padrão, ligue para:

_set_new_mode(1)

no início do seu programa ou o vínculo com o Newmode.obj.

Se um user-defined operator newfor fornecido, as novas funções de manipulador não são chamadas automaticamente em caso de falha.

Para obter mais informações, consulte nova e Excluir na Referência da linguagem C++.

Não há um único _set_new_handler manipulador para todas as DLLs vinculadas dinamicamente ou executáveis; mesmo se você chamar _set_new_handler o manipulador pode ser substituído por outro ou que você está substituindo um manipulador definido por outra DLL ou executável.

Requisitos

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

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

Exemplo

Neste exemplo, quando a alocação falha, o controle é transferido para MyNewHandler.O argumento passado para MyNewHandler é o número de bytes solicitados.O valor retornado de MyNewHandler é um sinalizador que indica se a alocação deve ser repetida: um valor diferente de zero indica que deve ser repetida a alocação e um valor zero indica que a alocação falhou.

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