Чому деструктор не викликається оператором видалення?

Я намагався закликати ::deleteдо класу в operator deleteцьому. Але деструктор не викликається.

Я визначив клас MyClass, operator deleteперевантажений яким. Глобальний operator deleteтакож перевантажений. Перевантажений operator deleteз MyClassвикликатиме перевантажений глобальної 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;
}

Вихід:

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

Фактична:

Існує тільки один виклик деструктора перед викликом перевантажений operator deleteз MyClass.

Очікується:

Є два виклики деструктора. Один перед викликом перевантажений operator deleteз MyClass. Ще одне перед викликом глобального operator delete.

Ви зловживаєте operator newі operator delete. Ці оператори виконують функції розподілу та розподілу. Вони не несуть відповідальності за будівництво або руйнування об'єктів. Вони відповідають лише за забезпечення пам'яті, в яку буде розміщений об'єкт.

Глобальні версії цих функцій є ::operator newі ::operator delete. ::newі ::deleteнове / ВИДАЛИТИ-вираз, як і new/ delete, що відрізняється від тих, що ::newі ::deleteбудуть обходити клас специфічних operator new/ operator deleteперевантаження.

Нові / delete-вирази будують / руйнують та розподіляють / ділокатують (викликаючи відповідні operator newабо operator deleteперед побудовою чи після знищення).

Оскільки ваше перевантаження відповідає лише за частину розподілу / розсилки, вона повинна викликати, ::operator newа ::operator deleteзамість ::newі ::delete.

deleteУ delete myClass;відповідає за виклик деструктора.

::delete p;не викликає деструктора, тому що pмає тип, void*і тому вираз не може знати, який деструктор викликати. Ймовірно, виклик вашої заміненої ::operator deleteмісцерозподілити пам'ять, хоча використання void*як операнда для виразу-виразу неправильно формується (див. Редагування нижче).

::new MyClass();викликає замінену, ::operator newщоб виділити пам'ять і побудує в ній об'єкт. Вказівник на цей об’єкт повертається як void*до нового виразу в MyClass* myClass = new MyClass();, який потім сконструює інший об’єкт у цій пам'яті, що закінчує термін дії попереднього об'єкта без виклику його деструктора.

Редагувати:

Завдяки коментарю @ MM до цього питання, я зрозумів, що void*як операнд ::deleteнасправді неправильно сформований. ( [expr.delete] / 1 ) Однак, схоже, основні компілятори вирішили лише попередити про це, а не помилку. Перед тим як це було зроблено погано сформованим, використовуючи ::deleteна void*було вже непередбачувана поведінка, см це питання .

Тому ваша програма неправильно сформована, і ви не маєте жодної гарантії, що код насправді виконує те, що я описав вище, якщо його все-таки вдалося скомпілювати.

Як вказує @SanderDeDycker нижче його відповіді, ви також маєте невизначене поведінку, оскільки, будуючи інший об’єкт у пам'яті, який вже містить MyClassоб'єкт, не викликаючи деструктора цього об’єкта, ви спочатку порушуєте [basic.life] / 5, що забороняє це робити, якщо Програма залежить від побічних ефектів деструктора. У цьому випадку printfзаява в деструкторі має такий побічний ефект.

Ваші класичні перевантаження виконані неправильно. Це можна побачити у вашому висновку: конструктор викликається двічі!

У конкретному класі operator newзателефонуйте глобальному оператору безпосередньо:

return ::operator new(size);

Аналогічно, у конкретному класі operator delete:

::operator delete(p);

operator newДетальнішу інформацію див. На довідковій сторінці.

Див. Довідку CPP :

operator delete, operator delete[]

Розподіляє попередньо виділене сховище operator new. Ці функції делокації викликаються видаленнями-виразами та новими виразами для розміщення пам’яті після руйнування (або неможливості побудови) об’єктів з динамічною тривалістю зберігання. Вони також можуть бути викликані за допомогою синтаксису звичайного виклику функції.

Видалення (та нові) відповідають лише за частину "управління пам'яттю".

Тож зрозуміло і очікується, що деструктор викликається лише один раз - для очищення екземпляра об'єкта. Як би його викликали двічі, кожен деструктор повинен був би перевірити, чи він уже викликався.