Warum wird der Destruktor im Operator delete nicht aufgerufen?

Ich habe versucht, ::deleteeine Klasse in der davon zu fordern operator delete. Aber der Destruktor wird nicht aufgerufen.

Ich habe eine Klasse definiert, MyClassderen operator deleteüberladen wurde. Das Globale operator deleteist ebenfalls überlastet. Die Überladung operator deletevon MyClassruft die überladene globale auf 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;
}

Die Ausgabe ist:

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

Tatsächlich:

Es gibt nur einen Aufruf an den destructor , bevor die überladenen Aufruf operator deletevon MyClass.

Erwartet:

Es gibt zwei Aufrufe an den Destruktor. Eine vor dem Aufruf der überladenen operator deletevon MyClass. Ein anderer vor dem Aufruf der globalen operator delete.

Sie missbrauchen operator newund operator delete. Diese Operatoren sind Zuordnungs- und Freigabefunktionen. Sie sind nicht verantwortlich für die Konstruktion oder Zerstörung von Objekten. Sie sind nur für die Bereitstellung des Speichers verantwortlich, in dem das Objekt platziert wird.

Die globalen Versionen dieser Funktionen sind ::operator newund ::operator delete. ::newund ::deletesind neue / delete-Ausdrücke, ebenso wie new/ delete, die sich darin unterscheiden, ::newund ::deleteumgehen klassenspezifische operator new/ operator deleteÜberladungen.

Die neuen / delete-Ausdrücke konstruieren / zerstören und ordnen / freigeben (durch Aufrufen des entsprechenden operator newoder operator deletevor dem Aufbau oder nach der Zerstörung).

Da Ihre Überlastung nur für den Zuordnungs- / Freigabe-Teil verantwortlich ist, sollte sie ::operator newund ::operator deleteanstelle von ::newund aufrufen ::delete.

Das deletein delete myClass;ist dafür verantwortlich, den Destruktor aufzurufen.

::delete p;ruft den Destruktor nicht auf, da er peinen Typ hat void*und der Ausdruck daher nicht wissen kann, welcher Destruktor aufgerufen werden soll. Wahrscheinlich wird Ihr Ersetzter aufgerufen, ::operator deleteum die Zuordnung des Speichers aufzuheben, obwohl die Verwendung eines void*as-Operanden für einen Löschausdruck falsch ist (siehe Bearbeitung unten).

::new MyClass();ruft Ihren ersetzten ::operator newauf, um Speicher zuzuweisen, und erstellt ein Objekt darin. Der Zeiger auf dieses Objekt wird in Bezug void*auf den neuen Ausdruck in zurückgegeben MyClass* myClass = new MyClass();, der dann ein anderes Objekt in diesem Speicher erstellt und die Lebensdauer des vorherigen Objekts beendet, ohne dessen Destruktor aufzurufen.

Bearbeiten:

Dank des Kommentars von @ MM zu dieser Frage wurde mir klar, dass ein void*Operand für ::deletetatsächlich schlecht geformt ist. ( [expr.delete] / 1 ) Die großen Compiler scheinen jedoch beschlossen zu haben, nur davor zu warnen, nicht vor Fehlern. Sehen Sie sich diese Frage an, bevor es schlecht geformt wurde und ::deleteein void*bereits undefiniertes Verhalten verwendet .

Daher ist Ihr Programm schlecht geformt und Sie haben keine Garantie dafür, dass der Code tatsächlich das tut, was ich oben beschrieben habe, wenn er noch kompiliert werden konnte.

Wie von @SanderDeDycker unter seiner Antwort ausgeführt, haben Sie auch ein undefiniertes Verhalten, da Sie durch das Erstellen eines anderen Objekts im Speicher, das bereits ein MyClassObjekt enthält, ohne zuerst den Destruktor dieses Objekts aufzurufen, gegen [basic.life] / 5 verstoßen, was dies verbietet, wenn das Programm hängt von den Nebenwirkungen des Destruktors ab. In diesem Fall hat die printfAnweisung im Destruktor einen solchen Nebeneffekt.

Ihre klassenspezifischen Überladungen werden falsch ausgeführt. Dies ist in Ihrer Ausgabe zu sehen: Der Konstruktor wird zweimal aufgerufen!

operator newRufen Sie im klassenspezifischen den globalen Operator direkt auf:

return ::operator new(size);

Führen Sie in der Klassenspezifischen Vorgehensweise operator deleteFolgendes aus:

::operator delete(p);

operator newWeitere Informationen finden Sie auf der Referenzseite.

Siehe CPP-Referenz :

operator delete, operator delete[]

Gibt die Zuweisung von Speicher frei, der zuvor durch einen Abgleich zugewiesen wurde operator new. Diese Freigabefunktionen werden durch Löschausdrücke und durch neue Ausdrücke aufgerufen, um die Zuordnung von Speicher aufzuheben, nachdem Objekte mit dynamischer Speicherdauer zerstört (oder nicht erstellt) wurden. Sie können auch mit der regulären Funktionsaufrufsyntax aufgerufen werden.

Löschen (und Neu) sind nur für den Teil 'Speicherverwaltung' verantwortlich.

Es ist also klar und zu erwarten, dass der Destruktor nur einmal aufgerufen wird - um die Instanz des Objekts zu bereinigen. Würde es zweimal aufgerufen, müsste jeder Destruktor prüfen, ob es bereits aufgerufen wurde.