He escrito el siguiente código que sobrecarga elnew ydelete operadores y lanza una excepción en el destructor.

Cuando se lanza la excepción, ¿por qué está el código en eldelete operador no ejecutado (y "adiós" impreso)?

Si no se debe ejecutar, ¿cómo se libera la memoria? Esuno de los otrosdelete operadores ¿llamado? ¿Sobrecargar uno de ellos resultaría en la ejecución del código correspondiente? ¿O simplemente no se libera la memoria porque una destrucción fallida implica que tal vez no debería serlo?

#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;
}

Salida:

hi
eek

Demo en vivo.

Miré:

arrojando excepciones de un destructor¿Cómo libera C ++ la memoria cuando un constructor lanza una excepción y se usa una nueva personalizada?Y otros

Pero no pude encontrar una respuesta a lo que sucede exactamente (1) para una excepción en el destructor (a diferencia del constructor) y (2) con una eliminación sobrecargada.

No necesito una conferencia sobre lanzar una excepción en un destructor que es una mala práctica: me encontré con un código similar y tengo curiosidad sobre el comportamiento.

Preferiría una respuesta respaldada por las referencias estándar o similares, si existen tales referencias.