_set_new_handler

Article
03/26/2013

Transfère le contrôle à votre mécanisme de gestion des erreurs si l'opérateur d' new n'allouent pas la mémoire.

_PNH _set_new_handler(
   _PNH pNewHandler 
);

Paramètres

pNewHandler
Pointeur vers une fonction fournie par l'application de gestion de mémoire.Un argument de 0 change le nouveau gestionnaire à supprimer.

Valeur de retour

Retourne un pointeur vers une fonction précédente de gestion des exceptions stockée par _set_new_handler, afin que la fonction précédente puisse être restaurées ultérieurement.si aucune fonction précédente n'a été définie, la valeur de retour peut être utilisée pour restaurer le comportement par défaut ; cette valeur peut être NULL.

Notes

La fonction C++ _set_new_handler spécifie une fonction de gestion des exceptions que les gains contrôlent si l'opérateur d' new n'allouent pas la mémoire.Si new échoue, le système runtime appelle automatiquement la fonction de gestion des exceptions qui a été passée comme argument à _set_new_handler._PNH, défini dans New.h, est un pointeur vers une fonction qui retourne tapez int et prend un argument de type size_t.Utilisez size_t pour spécifier la quantité d'espace à allouer.

il n'y a aucun gestionnaire par défaut.

_set_new_handler est principalement un modèle de garbage collection.Le système runtime recommencez l'allocation chaque fois que votre fonction retourne une valeur différente de zéro et il échoue si vos retourne 0 de fonction.

Une occurrence de la fonction d' _set_new_handler dans les registres de programme que la fonction de gestion des exceptions a spécifiés dans la liste d'arguments avec le système 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];
}

Vous pouvez enregistrer l'adresse de fonction qui était en dernier passée à la fonction de _set_new_handler et la rétablir ultérieurement :

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

La fonction C++ _set_new_mode définit le nouveau mode de gestionnaire pour malloc.Le nouveau mode de gestionnaire indique si, en cas de échec, malloc est d'appeler la nouvelle routine de gestionnaire comme définie par _set_new_handler.Par défaut, malloc n'appelle pas la nouvelle routine de gestionnaire en cas de échec pour allouer de la mémoire.Vous pouvez substituer ce comportement par défaut afin que, lorsque malloc n'allouent pas la mémoire, malloc appelle la nouvelle routine de gestionnaire de la même façon que l'opérateur d' new nécessaire si elle échoue pour la même raison.Pour substituer la valeur par défaut, appelez :

_set_new_mode(1)

tôt dans votre programme ou lien avec Newmode.obj.

si operator newdéfini par l'utilisateurest fourni, les nouvelles fonctions gestionnaires ne sont pas échec automatiquement invité.

Pour plus d'informations, consultez nouveau et le suppression dans le Guide de référence du langage C++.

Il existe un gestionnaire unique d' _set_new_handler pour toutes les DLL ou fichiers exécutables dynamiquement liés ; même si vous appelez _set_new_handler votre gestionnaire peut être remplacé par une autre ou que vous remplacez un gestionnaire défini par une DLL ou un fichier exécutable différent.

Configuration requise

routine	en-tête requis
_set_new_handler	<new.h>

Pour plus d'informations de compatibilité, consultez compatibilité dans l'introduction.

Exemple

Dans cet exemple, lorsque l'allocation échoue, le contrôle est transféré vers MyNewHandler.l'argument passé à MyNewHandler est le nombre d'octets demandés.La valeur retournée par MyNewHandler est une balise qui indique si l'allocation doit être réessayée : une valeur différente de zéro indique que l'allocation doit être réessayée, et une valeur zéro indique que l'allocation a échoué.

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