Was passiert mit dem Destruktor der Basisklasse, wenn ein abgeleiteter Klassendestruktor eine Exception auslöst

Question

Es ist mir einfach passiert, dass ich mich gefragt habe, wie Ressourcen im folgenden Fall freigegeben werden.

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 !? */ 
    } 
} 

Wird der Basisklassendestruktor aufgerufen, wenn der abgeleitete Klassendestruktor auswirft? Oder wird es ein Leck geben?

Answer 1

Nach §15.2/2:

Ein Objekt, das teilweise aufgebaut ist, wird teilweise oder Destruktoren für alle seine vollständig aufgebaut Subobjekte ausgeführt haben, zerstört werden, das heißt, für die Subobjekte, für die der Konstruktor Ausführung abgeschlossen hat und der Destruktor hat noch nicht mit der Ausführung begonnen.

So sollte der Basisklasse-Destruktor aufgerufen werden. Das heißt, wie wir wissen, das wird die Basisklasse aufzuräumen:

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

Und dass dies das Mitglied aufzuräumen:

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

Dies wird auch die Basisklasse aufzuräumen:

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

Das ist mein Verständnis des Zitats.

Answer 2

Der Basisdestruktor wird aufgerufen.

In Effektiv C++ empfiehlt Meyers, dass Ausnahmen Destruktoren nicht verlassen sollten. Fangen Sie die Ausnahme innerhalb des Destruktors und behandeln Sie es, schlucken Sie es oder beenden Sie es.

Answer 3

Die Basisklasse Destruktor wird in der Tat aufgerufen. Beispielcode:

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

Diese Drucke:

Derived 
Base 
CAUGHT!