¿Qué sucede con el destructor de la clase base si un destructor de clase derivado lanza una excepción?

Question

Me acaba de ocurrir. Me pregunté cómo se liberan los recursos en el siguiente caso.

class Base { 
    Resource *r; 

public: 
    Base() { /* ... */ } 
    ~Base() { 
    delete r; 
    } 
}; 

class Derived : public Base { 
public: 
    Derived() { /* ... */ } 
    ~Derived() { 
    /* Suddenly something here throws! */ 
    } 
}; 

int main() { 
    try { 
    Derived d; 
    } catch(...) { 
    /* what happened with Base::r !? */ 
    } 
} 

¿Se invocará el destructor de la clase base si arroja el destructor de clase derivado? ¿O habrá una fuga?

Answer 1

Según §15.2/2:

Un objeto que está construido parcialmente o parcialmente destruidas tendrá destructores ejecutados para todos sus subobjetos totalmente construido, es decir, para subobjetos para los que el constructor ha terminado la ejecución y el destructor aún no ha comenzado la ejecución.

Por lo que debe llamarse al destructor de la clase base. Es decir, al igual que sabemos que esto va a limpiar la clase base:

#include <iostream> 

struct foo 
{ 
    ~foo() 
    { 
     std::cout << "clean" << std::endl; 
    } 
}; 

struct bar : foo 
{ 
    bar() 
    { // foo is initialized... 
     throw 0; // ...so its destructor is run 
    } 
}; 

int main() 
{ 
    try 
    { 
     bar b; 
    } 
    catch (...) 
    { 
     std::cerr << "caught" << std::endl; 
    } 
} 

Y que esto va a limpiar el miembro:

#include <iostream> 

struct foo 
{ 
    ~foo() 
    { 
     std::cout << "clean" << std::endl; 
    } 
}; 

struct bar 
{ 
    ~bar() 
    { // f has been initialized... 
     throw 0; // ...so its destructor will run 
    } 

    foo f; 
}; 

int main() 
{ 
    try 
    { 
     bar b; 
    } 
    catch (...) 
    { 
     std::cerr << "caught" << std::endl; 
    } 
} 

Esto también va a limpiar la clase base:

#include <iostream> 

struct foo 
{ 
    ~foo() 
    { 
     std::cout << "clean" << std::endl; 
    } 
}; 

struct bar : foo 
{ 
    ~bar() 
    { // foo has been initialized... 
     throw 0; // ...so its destructor will run 
    } 
}; 

int main() 
{ 
    try 
    { 
     bar b; 
    } 
    catch (...) 
    { 
     std::cerr << "caught" << std::endl; 
    } 
} 

Esa es mi comprensión de la cita.

Answer 2

Se llamará al destructor base.

En Efectivo C++, Meyers recomienda que las excepciones no dejen destructores. Capture la excepción dentro del destructor y maneje, trague o termine.

Answer 3

De hecho, se llama al destructor de la clase base. Código de ejemplo:

#include 
#include 

class Base { 
public: 
    Base() { /* ... */ } 
    ~Base() { 
    printf("Base\n"); 
    } 
}; 

class Derived : public Base { 
public: 
    Derived() { /* ... */ } 
    ~Derived() { 
    printf("Derived\n"); 
    throw 1; 
    } 
}; 

int main() { 
    try { 
    Derived d; 
    } catch(...) { 
    printf("CAUGHT!\n"); 
    } 
} 

Esta impresora:

Derived 
Base 
CAUGHT!