Mengapa destruktor tidak dipanggil pada operator hapus?

Saya mencoba menelepon ::deleteuntuk kelas di operator deletedalamnya. Tetapi destruktor tidak disebut.

Saya mendefinisikan kelas MyClassyang operator deletekelebihan beban. Global operator deletejuga kelebihan beban. The kelebihan beban operator deletedari MyClassakan memanggil global kelebihan beban 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;
}

Outputnya adalah:

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

Sebenarnya:

Hanya ada satu panggilan untuk destructor sebelum memanggil kelebihan beban operator deletedari MyClass.

Diharapkan:

Ada dua panggilan ke destructor. Salah satu sebelum memanggil kelebihan beban operator deletedari MyClass. Lain sebelum memanggil global operator delete.

Anda menyalahgunakan operator newdan operator delete. Operator-operator ini adalah fungsi alokasi dan deallokasi. Mereka tidak bertanggung jawab untuk membangun atau merusak objek. Mereka bertanggung jawab hanya untuk menyediakan memori di mana objek akan ditempatkan.

Versi global dari fungsi-fungsi ini adalah ::operator newdan ::operator delete. ::newdan ::deleteyang baru / hapus-ekspresi, seperti new/ delete, berbeda dari yang, dalam hal itu ::newdan ::deleteakan memotong kelas-spesifik operator new/ operator deleteoverload.

Konstruksi baru / hapus-ekspresi / destruksi dan alokasikan / alokasikan (dengan memanggil yang sesuai operator newatau operator deletesebelum konstruksi atau setelah kehancuran).

Karena kelebihan Anda hanya bertanggung jawab untuk bagian alokasi / deallokasi, itu harus memanggil ::operator newdan ::operator deletebukannya ::newdan ::delete.

The deletedalam delete myClass;bertanggung jawab untuk memanggil destructor.

::delete p;tidak memanggil destruktor karena pmemiliki tipe void*dan oleh karena itu ekspresi tidak dapat mengetahui destruktor apa yang harus dipanggil. Mungkin akan memanggil Anda diganti ::operator deleteuntuk membatalkan alokasi memori, meskipun menggunakan void*operan as untuk menghapus-ekspresi tidak terbentuk (lihat edit di bawah).

::new MyClass();panggilan Anda diganti ::operator newuntuk mengalokasikan memori dan membangun objek di dalamnya. Pointer ke objek ini dikembalikan void*ke ekspresi-baru di MyClass* myClass = new MyClass();, yang kemudian akan membangun objek lain dalam memori ini, mengakhiri masa pakai objek sebelumnya tanpa memanggil destruktornya.

Edit:

Berkat komentar @ MM pada pertanyaan itu, saya menyadari bahwa void*operan as to not bad ::deleteformed. ( [expr.delete] / 1 ) Namun, kompiler utama tampaknya memutuskan untuk hanya memperingatkan tentang ini, bukan kesalahan. Sebelum itu dibuat sakit-terbentuk, menggunakan ::deletepada void*perilaku yang sudah terdefinisi punya, lihat pertanyaan ini .

Oleh karena itu, program Anda rusak dan Anda tidak memiliki jaminan bahwa kode tersebut benar-benar melakukan apa yang saya jelaskan di atas jika masih berhasil dikompilasi.

Seperti yang ditunjukkan oleh @SanderDeDycker di bawah jawabannya, Anda juga memiliki perilaku tidak terdefinisi karena dengan membangun objek lain di memori yang sudah berisi MyClassobjek tanpa memanggil destruktor objek itu terlebih dahulu Anda melanggar [basic.life] / 5 yang melarang melakukannya jika Program tergantung pada efek samping destruktor. Dalam hal ini printfpernyataan dalam destruktor memiliki efek samping seperti itu.

Kelebihan khusus kelas Anda dilakukan dengan tidak benar. Ini dapat dilihat pada output Anda: konstruktor dipanggil dua kali!

Di kelas khusus operator new, hubungi operator global secara langsung:

return ::operator new(size);

Demikian pula, di kelas khusus operator delete, lakukan:

::operator delete(p);

Lihat operator newhalaman referensi untuk lebih jelasnya.

Lihat Referensi CPP :

operator delete, operator delete[]

Deallocate storage yang sebelumnya dialokasikan oleh pencocokan operator new. Fungsi-fungsi deallokasi ini disebut dengan delete-expressions dan oleh new-expressions untuk mendeallocate memori setelah merusak (atau gagal membangun) objek dengan durasi penyimpanan dinamis. Mereka juga dapat dipanggil menggunakan sintaks panggilan fungsi biasa.

Hapus (dan baru) hanya bertanggung jawab untuk bagian 'manajemen memori'.

Jadi jelas dan diharapkan bahwa destructor hanya dipanggil sekali - untuk membersihkan instance objek. Apakah itu dipanggil dua kali, setiap destruktor harus memeriksa apakah sudah dipanggil.