_set_new_handler

Artigo
08/25/2010

Transfere o controle para o mecanismo de tratamento de erros se o new operador não pode alocar 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 por de manipulação de exceção anterior_set_new_handler, para que a função anterior pode ser restaurada posteriormente. Se nenhuma função anterior tiver sido conjunto, o valor retornado pode ser usado restauração o comportamento padrão, esse valor pode ser NULL.

Comentários

The C++ _set_new_handler função especifica uma função de manipulação de exceção que obtém controle se a new operador não pode alocar memória. If new falhar, o em time de execução sistema chama a função de manipulação de exceção foi passada sistema autônomo um argumento para automaticamente _set_new_handler. _PNH, definido no New.h, é um ponteiro para uma função que retorna o tipo int e leva um argumento de 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 em time de execução sistema repete a alocação de cada vez que a função retorna um valor diferente de zero e falhará se a função retornará 0.

Uma ocorrência do _set_new_handler função em um programa registra a função de manipulação de exceção especificada na lista de argumento com o sistema de time 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 passado pela última vez para o _set_new_handler função e reinstalá-lo posteriormente:

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

The C++ _set_new_mode função define o modo de manipulador de novo para malloc.O novo modo de manipulador indica se, no caso de falha, malloc é chamar a rotina manipuladora de novo sistema autônomo conjunto por _set_new_handler. Por padrão, malloc não telefonar a rotina manipuladora de novo no 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 de manipulador de novo na mesma forma que o new operador não quando ele falhar pelo mesmo motivo. Para substituir o padrão telefonar:

_set_new_mode(1)

desde o início em seu programa ou o link com Newmode.obj.

If a user-defined operator newis provided, the new handler functions are not automatically called on failure.

Para obter mais informações, consulte novo and Excluir in the Referência de linguagem C++.

Há um único _set_new_handler manipulador para todos os vinculados dinamicamente DLLs 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 pelo outro executável ou DLL.

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 do MyNewHandler é um sinalizar que indica se deve ser repetida alocação: 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();
}

Allocation failed. Coalescing heap.  This application has requested the Runtime to terminate it in an unusual way. Please contact the application's support team for more information.