_set_new_handler

Articolo
03/26/2013

Trasferisce il controllo al meccanismo di gestione degli errori se l'operatore new non riesce ad allocare memoria.

_PNH _set_new_handler(
   _PNH pNewHandler 
);

Parametri

pNewHandler
Puntatore alla funzione che gestisce la memoria fornita all'applicazione.Un argomento di 0 indica che il nuovo gestore deve essere rimosso.

Valore restituito

Restituisce un puntatore alla funzione precedente di gestione delle eccezioni registrata da _set_new_handler, in modo che la funzione precedente possa essere ripristinata in un secondo momento.Se nessuna funzione precedente è stata impostata, il valore restituito può essere utilizzato per ripristinare il comportamento predefinito, questo valore può essere NULL.

Note

La funzione C++ _set_new_handler specifica una funzione di gestione delle eccezioni che prende il controllo se l'operatore new non riesce ad allocare memoria.Se new non riesce, il sistema runtime chiama automaticamente la funzione di gestione delle eccezioni che è stata passata come argomento a _set_new_handler._PNH, definita in New.h, è un puntatore a una funzione che restituisce un int e accetta un argomento di tipo size_t.Utilizzare size_t per specificare la quantità di spazio da allocare in memoria.

Non esiste un gestore predefinito.

_set_new_handler è essenzialmente un garbage collection.Il sistema di runtime riprova l'allocazione ogni volta che la funzione restituisce un valore diverso da zero e avrà esito negativo altrimenti.

Un'occorrenza della funzione _set_new_handler nei registri del programma, la funzione di gestione delle eccezioni specificata nella lista degli argomenti con il sistema di runtime:

#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];
}

È possibile salvare l'indirizzo dell'ultima funzione passata alla funzione _set_new_handler e reintegrarlo in seguito:

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

La funzione C++ _set_new_mode imposta la nuova modalità di gestione per la funzione malloc.La nuova modalità di gestione indica che, in caso di errore, malloc deve richiamare la nuova routine di gestione come impostato da _set_new_handler.Per impostazione predefinita, malloc non richiama la nuova routine di gestione in caso di errore nell'allocare memoria.È possibile eseguire l'override di questo comportamento predefinito in modo che, quando malloc non riesce ad allocare memoria, malloc richiami la nuova routine del gestore allo stesso modo di come accade con l'operatore new quando si verifica il medesimo errore.Per eseguire l'override del comportamento predefinito, chiamare:

_set_new_mode(1)

all'inizio del programma programma o collegare con Newmode.obj.

Se viene fornito un operator newdefinito dall'utente, le nuove funzioni di gestione non vengono richiamate automaticamente in caso di errore.

Per ulteriori informazioni, vedere nuovo e elimina in Riferimenti al linguaggio C++.

Esiste un unico gestore _set_new_handler per tutte le DLL collegate in modo dinamico o gli eseguibili; anche se si chiama _set_new_handler il gestore può solo essere sostituito da un altro o eventualmente sostituire uno già impostato da qualche DLL o eseguibile.

Requisiti

Routine	Intestazione obbligatoria
_set_new_handler	<new.h>

Per ulteriori informazioni sulla compatibilità, vedere Compatibilità nell'introduzione.

Esempio

In questo esempio, quando l'allocazione ha esito negativo, il controllo viene trasferito a MyNewHandler.L'argomento passato a MyNewHandler è il numero di byte necessari.Il valore restituito da MyNewHandler è un flag che indica se l'allocazione deve essere ripetuta: un valore diverso da zero indica che l'allocazione deve essere ripetuta e un valore zero indica che l'allocazione non è riuscita.

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