Eu escrevi o código abaixo que sobrecarrega onew edelete operadores e lança uma exceção no destruidor.

Quando a exceção é lançada, por que o código está nodelete operador não executado (e "tchau" impresso)?

Se não deveria ser executado, (como) a memória é liberada? Éum dos outrosdelete operadores chamado? Sobrecarregar um deles resultaria na execução do código correspondente? Ou a memória simplesmente não é liberada porque uma destruição falhada implica que talvez não deva ser?

#include <iostream>
using namespace std;
class A
{
public:
    A() { }
    ~A() noexcept(false) { throw exception(); }
    void* operator new (std::size_t count)
    {
        cout << "hi" << endl;
        return ::operator new(count);
    }
    void operator delete (void* ptr)
    {
        cout << "bye" << endl;
        return ::operator delete(ptr);
    }
    // using these (with corresponding new's) don't seem to work either
    // void operator delete (void* ptr, const std::nothrow_t& tag);
    // void operator delete (void* ptr, void* place);
};

int main()
{
    A* a = new A();
    try
    {
        delete a;
    }
    catch(...)
    {
        cout << "eek" << endl;
    }
    return 0;
}

Resultado:

hi
eek

Demonstração ao vivo.

Eu olhei para:

jogando exceções fora de um destruidorComo o C ++ libera a memória quando um construtor lança uma exceção e um novo personalizado é usadoE outros

Mas não consegui encontrar uma resposta para o que exatamente acontece (1) para uma exceção no destruidor (em oposição ao construtor) e (2) com uma exclusão sobrecarregada.

Não preciso de uma palestra sobre como lançar uma exceção em um destruidor por ser uma prática ruim - apenas encontrei um código semelhante e estou curioso sobre o comportamento.

Eu preferiria uma resposta suportada pelas referências padrão ou similares, se essas referências existirem.