This documentation is archived and is not being maintained.


Transfers control to your error-handling mechanism if the new operator fails to allocate memory.

_PNH _set_new_handler(
   _PNH pNewHandler 


Pointer to the application-supplied memory handling function. An argument of 0 causes the new handler to be removed.

Return Value

Returns a pointer to the previous exception handling function registered by _set_new_handler, so that the previous function can be restored later. If no previous function has been set, the return value may be used to restore the default behavior; this value may be NULL.


The C++ _set_new_handler function specifies an exception-handling function that gains control if the new operator fails to allocate memory. If new fails, the run-time system automatically calls the exception-handling function that was passed as an argument to _set_new_handler. _PNH, defined in NEW.H, is a pointer to a function that returns type int and takes an argument of type size_t. Use size_t to specify the amount of space to be allocated.

There is no default handler.

_set_new_handler is essentially a garbage-collection scheme. The run-time system retries allocation each time your function returns a nonzero value and fails if your function returns 0.

An occurrence of the _set_new_handler function in a program registers the exception-handling function specified in the argument list with the run-time system:

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

You can save the function address that was last passed to the _set_new_handler function and reinstate it later:

_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 function sets the new handler mode for malloc. The new handler mode indicates whether, on failure, malloc is to call the new handler routine as set by _set_new_handler. By default, malloc does not call the new handler routine on failure to allocate memory. You can override this default behavior so that, when malloc fails to allocate memory, malloc calls the new handler routine in the same way that the new operator does when it fails for the same reason. To override the default, call


early in your program or link with NEWMODE.OBJ.

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

For more information, see new and delete in the C++ Language Reference.

There is a single _set_new_handler handler for all dynamically linked DLLs or EXEs; even if you call _set_new_handler your handler may be replaced by another or that you are replacing a handler set by another DLL or EXE.


Routine Required header Compatibility
_set_new_handler <new.h> Win 98, Win Me, Win NT, Win 2000, Win XP

For additional compatibility information, see Compatibility in the Introduction.


All versions of the C run-time libraries.


In this example, when the allocation fails, control is transferred to MyNewHandler. The argument passed to MyNewHandler is the number of bytes requested. The value returned from MyNewHandler is a flag indicating whether allocation should be retried: a nonzero value indicates that allocation should be retried, and a zero value indicates that allocation has failed.

// crt_set_new_handler.cpp
#include <stdio.h>
#include <new.h>
#define BIG_NUMBER 100000000000000

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)
   return 0;

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


Allocation failed. Coalescing heap.

See Also

Memory Allocation Routines | calloc | free | realloc | Run-Time Routines and .NET Framework Equivalents