_set_new_handler

Artículo
04/10/2013

Transfiere el control al mecanismo de control de errores si el operador de new no puede para asignar memoria.

_PNH _set_new_handler(
   _PNH pNewHandler 
);

Parámetros

pNewHandler
puntero a memoria aplicación-proporcionada que administra la función.Un argumento de 0 hace que el nuevo controlador que se va a quitar.

Valor devuelto

Devuelve un puntero a la función anterior del control de excepciones registrada por _set_new_handler, para poder restaurar la función anterior más adelante.Si no se ha establecido ninguna función anterior, el valor devuelto se puede utilizar para restaurar el comportamiento predeterminado; este valor puede ser NULL.

Comentarios

La función de C++ _set_new_handler especifica una función de control de excepciones que control de mejoras si el operador de new no puede para asignar memoria.Si se produce new , el sistema en tiempo de ejecución llama automáticamente a la función de control de excepciones que se pasa como argumento a _set_new_handler._PNH, definido en New.h, es un puntero a una función que devuelve el tipo int y toma un argumento de size_tescrito.Utilice size_t para especificar la cantidad de espacio que se asignará.

No hay ningún controlador predeterminado.

_set_new_handler es esencialmente un esquema de recolección de elementos no utilizados.El sistema de motor en tiempo de ejecución reintenta la asignación cada vez que la función devuelve un valor distinto de cero y no se supera si la función devuelve 0.

Una aparición de la función de _set_new_handler en registros de un programa que la función de control de excepciones especificado en la lista de argumentos con el sistema en tiempo de ejecución:

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

Puede guardar la dirección de función que se pasó por última vez a la función de _set_new_handler y reinstalarla posterior:

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

La función de C++ _set_new_mode establece el nuevo modo de controlador para malloc.El nuevo modo de controlador indica si, en el error, malloc es llamar a la nueva rutina de controlador como lo establece _set_new_handler.De forma predeterminada, malloc no llama a la nueva rutina de controlador en el error asignar memoria.Puede invalidar este comportamiento predeterminado para que, cuando malloc no puede para asignar memoria, malloc llame a la nueva rutina del controlador de la misma manera que el operador de new cuando falla por la misma razón.Para reemplazar el valor predeterminado, llame a:

_set_new_mode(1)

al principio del programa o el vínculo con Newmode.obj.

Si se proporciona operator newdefinido por el usuario, las nuevas funciones controladoras no son error automáticamente invitado.

Para obtener más información, vea nuevo y cancelación en la referencia del lenguaje C++.

Hay solo controlador de _set_new_handler para todos los archivos DLL o ejecutables dinámicamente vinculados; incluso si llama a _set_new_handler el controlador podría reemplazar por otro o que se está reemplazando un controlador establecido por otra DLL o ejecutable.

Requisitos

rutina	Encabezado necesario
_set_new_handler	<new.h>

Para obtener más información de compatibilidad, vea compatibilidad en la Introducción.

Ejemplo

En este ejemplo, cuando se produce un error en la asignación, el control se transfiere a MyNewHandler.el argumento pasado a MyNewHandler es el número de bytes solicitados.El valor devuelto de MyNewHandler es una marca que indica si la asignación debe reintentar: un valor distinto de cero indica que la asignación debe reintentar, y un valor cero indica que se ha producido un error en la asignación.

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