Pourquoi le destructeur n'est-il pas appelé dans la suppression de l'opérateur?

J'ai essayé d'appeler ::deletepour une classe dans le operator deletede celui-ci. Mais le destructeur n'est pas appelé.

J'ai défini une classe MyClassqui operator deletea été surchargée. Le global operator deleteest également surchargé. La surcharge operator deletede MyClassnommerez mondiale surchargée operator delete.

class MyClass
{
public:
    MyClass() { printf("Constructing MyClass...\n"); }
    virtual ~MyClass() { printf("Destroying MyClass...\n"); }

    void* operator new(size_t size)
    {
        printf("Newing MyClass...\n");
        void* p = ::new MyClass();
        printf("End of newing MyClass...\n");
        return p;
    }

    void operator delete(void* p)
    {
        printf("Deleting MyClass...\n");
        ::delete p;    // Why is the destructor not called here?
        printf("End of deleting MyClass...\n");
    }
};

void* operator new(size_t size)
{
    printf("Global newing...\n");
    return malloc(size);
}

void operator delete(void* p)
{
    printf("Global deleting...\n");
    free(p);
}

int main(int argc, char** argv)
{
    MyClass* myClass = new MyClass();
    delete myClass;

    return EXIT_SUCCESS;
}

La sortie est:

Newing MyClass...
Global newing...
Constructing MyClass...
End of newing MyClass...
Constructing MyClass...
Destroying MyClass...
Deleting MyClass...
Global deleting...
End of deleting MyClass...

Réel:

Il n'y a qu'un seul appel au destructeur avant d'appeler le surchargé operator deletede MyClass.

Attendu:

Il y a deux appels au destructeur. Un avant d'appeler le surchargé operator deletede MyClass. Un autre avant d'appeler le mondial operator delete.

Vous abusez operator newet operator delete. Ces opérateurs sont des fonctions d'allocation et de désallocation. Ils ne sont pas responsables de la construction ou de la destruction d'objets. Ils sont uniquement responsables de fournir la mémoire dans laquelle l'objet sera placé.

Les versions globales de ces fonctions sont ::operator newet ::operator delete. ::newet ::deletesont nouvelles / delete-expressions, tout comme new/ delete, différentes de celles dans la mesure où ::newet ::deleteclasse spécifiques contournent operator new/ operator deletesurcharges.

Les nouvelles / delete-expressions construisent / détruisent et allouent / désallouent (en appelant la appropriée operator newou operator deleteavant la construction ou après la destruction).

Étant donné que votre surcharge n'est responsable que de la partie allocation / désallocation, elle doit appeler ::operator newet ::operator deleteau lieu de ::newet ::delete.

L' deleteentrée delete myClass;est chargée d'appeler le destructeur.

::delete p;n'appelle pas le destructeur car pa type void*et par conséquent l'expression ne peut pas savoir quel destructeur appeler. Il appellera probablement votre remplaçant ::operator deletepour désallouer la mémoire, bien que l'utilisation d'un void*opérande as pour une expression de suppression soit mal formée (voir modification ci-dessous).

::new MyClass();appelle votre remplacée ::operator newpour allouer de la mémoire et y construit un objet. Le pointeur vers cet objet est renvoyé quant void*à la nouvelle expression dans MyClass* myClass = new MyClass();, qui va ensuite construire un autre objet dans cette mémoire, mettant fin à la durée de vie de l'objet précédent sans appeler son destructeur.

Éditer:

Grâce au commentaire de @ MM sur la question, j'ai réalisé qu'un void*opérande as ::deleteest en fait mal formé. ( [expr.delete] / 1 ) Cependant, les principaux compilateurs semblent avoir décidé de ne prévenir que de cela, pas d'erreur. Avant de devenir mal formé, d'utiliser ::deleteun void*comportement déjà indéfini, voir cette question .

Par conséquent, votre programme est mal formé et vous n'avez aucune garantie que le code fait réellement ce que j'ai décrit ci-dessus s'il parvient toujours à compiler.

Comme l'a souligné @SanderDeDycker ci-dessous sa réponse, vous avez également un comportement indéfini car en construisant un autre objet dans la mémoire qui contient déjà un MyClassobjet sans appeler d'abord le destructeur de cet objet, vous violez [basic.life] / 5 qui interdit de le faire si le programme dépend des effets secondaires du destructeur. Dans ce cas, l' printfinstruction dans le destructeur a un tel effet secondaire.

Vos surcharges spécifiques à la classe ne sont pas effectuées correctement. Cela peut être vu dans votre sortie: le constructeur est appelé deux fois!

Dans la classe spécifique operator new, appelez directement l'opérateur global:

return ::operator new(size);

De même, dans la classe spécifique operator delete, faites:

::operator delete(p);

Référez-vous à la operator newpage de référence pour plus de détails.

Voir la référence du RPC :

operator delete, operator delete[]

Désalloue le stockage précédemment alloué par une correspondance operator new. Ces fonctions de désallocation sont appelées par des expressions de suppression et par de nouvelles expressions pour désallouer de la mémoire après avoir détruit (ou échoué à construire) des objets avec une durée de stockage dynamique. Ils peuvent également être appelés à l'aide de la syntaxe d'appel de fonction régulière.

Supprimer (et nouveau) ne sont responsables que de la partie «gestion de la mémoire».

Il est donc clair et attendu que le destructeur n'est appelé qu'une seule fois - pour nettoyer l'instance de l'objet. S'il était appelé deux fois, chaque destructeur devrait vérifier s'il avait déjà été appelé.