Comment dois-je écrire ISO C++ Standard conforme personnalisé nouveau et supprimer des opérateurs?

Partie II

... suite

Étant donné le comportement de operator new de l'exemple, un bien conçu new_handler doit effectuez l'une des opérations suivantes:

Faire plus de mémoire disponible: Cela peut permet la prochaine allocation de mémoire tentative à l'intérieur de nouvel opérateur de boucle pour réussir. Une façon de mettre en œuvre ce qui est d'allouer un bloc de mémoire au démarrage du programme, puis relâchez-la pour l'utiliser dans le programme la première fois le nouveau gestionnaire est appelé.

Installer un autre nouveau-gestionnaire: Si le nouveau gestionnaire peut pas faire plus de mémoire disponible, et de là est un autre nouveau-gestionnaire peut, alors le courant de la nouvelle-gestionnaire peut installer les autres nouveau-chien à sa place (en appelant set_new_handler). La prochaine fois opérateur de nouveaux appels à la nouvelle fonction de gestionnaire, elle permettra d'obtenir la plus récente.

(Une variation sur ce thème est pour un nouveau gestionnaire pour modifier son propre comportement, de sorte que la prochaine fois qu'il est invoqué, il fait quelque chose de différent. Une façon d'y parvenir est d'avoir la nouvelle-gestionnaire de modifier statique, de l'espace de noms spécifique, ou de données mondiale qui affecte le nouveau gestionnaire du comportement.)

Désinstaller le nouveau gestionnaire: Cela se fait en passant un pointeur null pour set_new_handler. En l'absence de nouveau gestionnaire d'installé, operator new va lever une exception (convertibles) std::bad_alloc) lorsque l'allocation de mémoire est un échec.

Lever une exception convertibles std::bad_alloc. Ces exceptions ne sont pas être pris par operator new, mais va se propager vers le site d'origine de la demande de mémoire.

Pas de retour: En appelant abort ou exit.

De mettre en œuvre une classe spécifique new_handler nous avons de fournir une classe avec ses propres versions de set_new_handler et operator new. La classe set_new_handler permet aux clients de spécifier la nouvelle-gestionnaire pour la classe (exactement comme la norme de set_new_handlerpermet aux clients de spécifier la nouvelle-gestionnaire). La classe operator new s'assure que les classe spécifique de la nouvelle-gestionnaire est utilisé à la place de la global new-gestionnaire de la mémoire pour les objets de classe est attribué.

Maintenant que nous comprenons new_handler & set_new_handler mieux, nous sommes en mesure de modifier la Exigence n ° 4 convenablement comme:

Exigence N ° 4 (Amélioré):

Notre operator new devriez essayer d'allouer de la mémoire plus d'une fois, l'appel de la nouvelle fonction de traitement après chaque échec. L'hypothèse ici est que la nouvelle fonction de gestion pourraient être en mesure de faire quelque chose pour libérer de la mémoire. Seulement lorsque le pointeur de la nouvelle fonction de gestion est null ne operator new lever une exception.

Comme promis, la référence de la Norme:

Section 3.7.4.1.3:

Une fonction d'allocation qui ne parvient pas à allouer du stockage peut invoquer la actuellement installés new_handler(18.4.2.2), le cas échéant. [Note: Un programme fourni par l'allocation de fonction peut obtenir l'adresse de la actuellement installés new_handler à l'aide de la set_new_handler fonction (18.4.2.3).] Si une fonction d'allocation déclaré avec un vide spécification d'exception (15.4), throw(), ne parvient pas à allouer du stockage, il doit retourner un pointeur null. Toute autre fonction d'allocation qui ne parvient pas à allouer du stockage doit seulement indiquer l'échec par la jet-ing une exception de classe std::bad_alloc (18.4.2.1) ou d'une classe dérivée de std::bad_alloc.

Armé avec la #4 exigences, nous allons tenter le pseudo-code pour notre new operator:

void * operator new(std::size_t size) throw(std::bad_alloc)
{  
   //custom operator new might take additional params(3.7.3.1.1)

    using namespace std;                 
    if (size == 0)                     //handle 0-byte requests
    {                     
        size = 1;                      //by treating them as
    }                                  //1-byte requests

    while (true) 
    {
        //attempt to allocate size bytes;

        //if (the allocation was successful)

        //return (a pointer to the memory);

        //allocation was unsuccessful; find out what the current new-handling function is (see below)
        new_handler globalHandler = set_new_handler(0);

        set_new_handler(globalHandler);


        if (globalHandler)             //If new_hander is registered call it
             (*globalHandler)();
        else 
             throw std::bad_alloc();   //No handler is registered throw an exception

    }

}

Poursuite 2

La mise en œuvre d'une coutume opérateur delete

La Norme C++ (§18.4.1.1) bibliothèque définit operator delete comme:

void operator delete(void*) throw();

Nous répétons l'exercice de collecte des exigences pour l'écriture de notre coutume operator delete:

Exigence n ° 1:
Il doit retourner void et son premier paramètre doit être void*. Une coutume delete operator peut avoir plus d'un seul paramètre, mais bien nous avons juste besoin d'un paramètre à passer le pointeur pointant vers la mémoire allouée.

Citation de la Norme C++:

Section §3.7.3.2.2:

"Chaque fonction de libération est de retour void et son premier paramètre est vide*. Une fonction de libération peut avoir plus d'un paramètre....."

Exigence n ° 2: Il doit garantir qu'il est plus sûr de supprimer un pointeur null dans le passé comme argument.

Citation par la Norme C++:
Section §3.7.3.2.3:

La valeur du premier argument fourni à l'un de la libération de la mémoire de fonctions de la bibliothèque standard, peut être une valeur de pointeur null; si donc, l'appel à la fonction de libération n'a pas d'effet. Sinon, la valeur fournie à operator delete(void*) dans la bibliothèque standard doit être l'une des valeurs retournées par un appel précédent de operator new(size_t) ou operator new(size_t, const std::nothrow_t&) dans la bibliothèque standard, et la valeur fournie à operator delete[](void*) dans la bibliothèque standard doit être l'une des valeurs retournées par un appel précédent de operator new[](size_t) ou operator new[](size_t, const std::nothrow_t&) dans la bibliothèque standard.

Exigence n ° 3:
Si le pointeur passé n'est pas null, puis le delete operator devrait libérer la dynamique de la mémoire allouée et attribuée au pointeur.

Citation par la Norme C++:
Section §3.7.3.2.4:

Si l'argument donné à une fonction de libération de la bibliothèque standard est un pointeur qui n'est pas la valeur de pointeur null (4.10), la fonction de libération est de libérer le stockage référencé par le pointeur, le rendu invalide tous les pointeurs se référant à une partie de la désallocation de stockage.

Exigence n ° 4:
Aussi, depuis notre spécifiques à la classe de nouvel opérateur transfère les demandes de la "mauvaise" taille de ::operator new, Nous DOIT de l'avant "à tort" de la taille de la suppression des demandes de ::operator delete.

Donc, sur la base des exigences, nous avons résumé ci-dessus est ici d'un standard conforme pseudo-code pour un custom delete operator:

class Base
{
    public:
        //Same as before
        static void * operator new(std::size_t size) throw(std::bad_alloc);
        //delete declaration
        static void operator delete(void *rawMemory, std::size_t size) throw();

        void Base::operator delete(void *rawMemory, std::size_t size) throw()
        {
            if (rawMemory == 0)
            {
                return;                            //No-Op is null pointer
            }

            if (size != sizeof(Base))
            {
                //if size is "wrong,"
                ::operator delete(rawMemory);      //Delegate to std::delete
                return;
            }
            //If we reach here means we have correct sized pointer for deallocation
            //deallocate the memory pointed to by rawMemory;

            return;
        }
};