Por que o destruidor não é chamado na exclusão do operador?

Eu tentei chamar ::deleteuma aula operator deletesobre isso. Mas o destruidor não é chamado.

Eu defini uma classe MyClassque operator deletefoi sobrecarregada. O global operator deletetambém está sobrecarregado. O sobrecarregado operator deletede MyClasschamará o global sobrecarregado 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;
}

A saída é:

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

Real:

Há apenas uma chamada para o destruidor antes de chamar a sobrecarga operator deletede MyClass.

Esperado:

Existem duas chamadas para o destruidor. Um antes de chamar o sobrecarregado operator deletede MyClass. Outro antes de chamar o global operator delete.

Você está usando mal operator newe operator delete. Esses operadores são funções de alocação e desalocação. Eles não são responsáveis ​​por construir ou destruir objetos. Eles são responsáveis ​​apenas por fornecer a memória na qual o objeto será colocado.

As versões globais dessas funções são ::operator newe ::operator delete. ::newe ::deletesão novas / delete-expression, assim como são new/ delete, diferentes daquelas ::newe ::deleteignoram sobrecargas operator new/ classes específicas operator delete.

O novo / delete-expression constrói / destrói e aloca / desaloca (chamando o apropriado operator newou operator deleteantes da construção ou após a destruição).

Como sua sobrecarga é responsável apenas pela parte de alocação / desalocação, ela deve chamar ::operator newe, em ::operator deletevez de ::newe ::delete.

O deletein delete myClass;é responsável por chamar o destruidor.

::delete p;não chama o destruidor porque ptem tipo void*e, portanto, a expressão não pode saber qual destruidor chamar. Provavelmente chamará seu substituído ::operator deletepara desalocar a memória, embora o uso de um void*operando como para uma expressão de exclusão esteja mal formado (veja a edição abaixo).

::new MyClass();chama seu substituído ::operator newpara alocar memória e constrói um objeto nele. O ponteiro para esse objeto é retornado quanto void*à nova expressão em MyClass* myClass = new MyClass();, que então constrói outro objeto nessa memória, encerrando a vida útil do objeto anterior sem chamar seu destruidor.

Editar:

Graças ao comentário de @ MM sobre a questão, percebi que um void*operando as ::deleteé realmente mal formado. ( [expr.delete] / 1 ) No entanto, os principais compiladores parecem ter decidido apenas avisar sobre isso, não erro. Antes de ficar mal formado, usando ::deleteum void*comportamento já indefinido, consulte esta pergunta .

Portanto, seu programa está mal formado e você não tem garantia de que o código realmente faça o que eu descrevi acima se ele ainda conseguiu compilar.

Conforme apontado por @SanderDeDycker abaixo da resposta, você também tem um comportamento indefinido porque, ao construir outro objeto na memória que já contém um MyClassobjeto sem chamar primeiro o destruidor desse objeto, você está violando [basic.life] / 5, que o proíbe se o programa depende dos efeitos colaterais do destruidor. Nesse caso, a printfdeclaração no destruidor tem esse efeito colateral.

Suas sobrecargas específicas da classe são feitas incorretamente. Isso pode ser visto em sua saída: o construtor é chamado duas vezes!

Na classe específica operator new, chame o operador global diretamente:

return ::operator new(size);

Da mesma forma, no específico da classe operator delete, faça:

::operator delete(p);

Consulte a operator newpágina de referência para mais detalhes.

Consulte Referência de CPP :

operator delete, operator delete[]

Desaloca o armazenamento alocado anteriormente por uma correspondência operator new. Essas funções de desalocação são chamadas por expressões de exclusão e novas expressões para desalocar a memória após a destruição (ou falha na construção) de objetos com duração de armazenamento dinâmico. Eles também podem ser chamados usando a sintaxe de chamada de função regular.

Excluir (e novo) são responsáveis ​​apenas pela parte 'gerenciamento de memória'.

Portanto, é claro e esperado que o destruidor seja chamado apenas uma vez - para limpar a instância do objeto. Seria chamado duas vezes, todo destruidor teria que verificar se já havia sido chamado.