Namespaces
Variants

std::set_new_handler

De fr.cppreference.net
 
 
Bibliothèque d'utilitaires
Support du langage
Support des types (types de base, RTTI)
Macros de test de fonctionnalités de la bibliothèque (C++20)
Utilitaires de programme
Fonctions variadiques
Support des coroutines (C++20)
Support des contrats (C++26)
Comparaison à trois voies
(C++20)
(C++20)(C++20)(C++20)    
(C++20)(C++20)(C++20)

Utilitaires généraux
Opérateurs relationnels (déprécié en C++20)
 
Bibliothèque de gestion de la mémoire
Allocateurs
Ressources mémoire
Stockage non initialisé (jusqu'à C++20*)
Support du ramasse-miettes (jusqu'à C++23)
 
 
Défini dans l'en-tête <new>
std::new_handler set_new_handler( std::new_handler new_p ) throw();
(jusqu'à C++11)
std::new_handler set_new_handler( std::new_handler new_p ) noexcept;
(depuis C++11)

Définit new_p la nouvelle fonction new-handler globale et retourne le new-handler précédemment installé.

La new-handler est la fonction appelée par les fonctions d'allocation chaque fois qu'une tentative d'allocation mémoire échoue. Son objectif prévu est l'une des trois choses suivantes :

1) rendre plus de mémoire disponible,
2) terminer le programme (par exemple en appelant std::terminate),
3) lancer une exception de type std::bad_alloc ou dérivée de std::bad_alloc.

L'implémentation par défaut lance std::bad_alloc. L'utilisateur peut installer son propre new-handler, qui peut offrir un comportement différent de celui par défaut.

Si new-handler retourne, la fonction d'allocation répète la tentative d'allocation précédemment échouée et appelle le new-handler à nouveau si l'allocation échoue encore. Pour terminer la boucle, new-handler peut appeler std::set_new_handler(nullptr): si, après une tentative d'allocation échouée, la fonction d'allocation constate que std::get_new_handler retourne une valeur de pointeur nul, elle lancera std::bad_alloc.

Au démarrage du programme, new-handler est un pointeur nul.

Cette fonction est thread-safe. Chaque appel à std::set_new_handler synchronizes-with (voir std::memory_order) les appels ultérieurs à std::set_new_handler et std::get_new_handler.

(depuis C++11)

Paramètres

new_p - pointeur vers une fonction de type std::new_handler , ou pointeur nul

Valeur de retour

Le gestionnaire de nouvelle installation précédent, ou une valeur de pointeur nul si aucun n'était installé.

Exemple

#include <iostream>
#include <new>
void handler()
{
    std::cout << "Memory allocation failed, terminating\n";
    std::set_new_handler(nullptr);
}
int main()
{
    std::set_new_handler(handler);
    try
    {
        while (true)
        {
            new int[1000'000'000ul]();
        }
    }
    catch (const std::bad_alloc& e)
    {
        std::cout << e.what() << '\n';
    }
}

Sortie possible :

Memory allocation failed, terminating
std::bad_alloc

Voir aussi

fonctions d'allocation
(fonction)
obtient le gestionnaire new actuel
(fonction)
type de pointeur de fonction du gestionnaire new
(typedef)
exception levée lorsque l'allocation de mémoire échoue
(classe)