Perché i distruttori non vengono chiamati quando un'eccezione non rilevata viene lanciata in C++ durante la creazione dell'array?

Question

class XX 
{ 
public: 
    static unsigned s_cnt; 
    XX() 
    { 
     ++ s_cnt; 
     std::cout << "C XX " << s_cnt << "\n"; 

     if (s_cnt > 2) 
      throw std::exception(); 
    } 

    //private: 
    ~XX() 
    { 
     std::cout << "~ XX\n"; 
    } 
}; 
unsigned XX::s_cnt = 0; 

int main() 
{ 
    try 
    { 
     XX *xx = new XX[10]; 
    } catch (...) 
    { 
     std::cout << "Exc\n"; 
    } 
} 

uscita:

C XX 1 
C XX 2 
C XX 3 
~ XX 
~ XX 
Exc 

Ma quando rimuovo try-catch, vedo:

C XX 1 
C XX 2 
C XX 3 
terminate called after throwing an instance of 'std::exception' 
    what(): std::exception 
zsh: abort  ./a.out 

Perché C++ chiamare i distruttori in primo caso ma non nel secondo?

Answer 1

Quando non si rileva un'eccezione (cioè diventa un'eccezione non rilevata e termina il programma), C++ non offre alcuna garanzia che i distruttori vengano effettivamente chiamati.

Ciò fornisce al margine del compilatore come implementare la gestione delle eccezioni. Ad esempio, GCC prima cerca un gestore. Se non riesce a trovarne uno, si interrompe immediatamente, conservando le informazioni complete sullo stack per il debug. Se ne trova uno, in realtà svolge lo stack, distruggendo oggetti, finché non arriva al gestore. Ecco perché non vedi l'output: il programma si interrompe prima di distruggere qualsiasi oggetto.

Answer 2

Quando si genera un'eccezione da un costruttore, lo standard considera l'oggetto come non creato. Non distruggi qualcosa che non esiste, vero?

In realtà, anche questo semplice esempio non funziona come lei suggerisce:

struct A { 
    A() {throw std::exception();} 
    ~A() {std::cout << "A::~A()" << std::endl;} 
}; 

int main() { 
    A a; 
} 

Questa termina con un'eccezione non rilevata, ma non viene stampata "A :: ~ A()".

Se ci pensi, è l'unico modo possibile per dare un semantico ad esso.

Ad esempio, possiamo usare il nostro tipo A come un oggetto di membro di una classe B:

struct B { 
    B() : m_a(),m_p(new int) {} 
    ~B() {delete m_p;} 

    A m_a; 
    int * m_p; 
}; 

Ovviamente B::B() getta immediatamente (e non anche inizializzare m_p). Se un ipotetico standard C++ richiede chiamate allo B::~B() in questo caso, il distruttore non ha modo di sapere se m_p è stato inizializzato o meno.

In altre parole, il lancio di un'eccezione da un costruttore significa che l'oggetto non è mai esistito e la sua durata non è mai iniziata. Questo GotW è abbastanza chiaro a riguardo.

Bonus: cosa succede se nella definizione di B scambiamo l'ordine di m_a e m_p? Quindi si verifica una perdita di memoria. Ecco perché esiste una sintassi particolare per rilevare l'eccezione durante l'inizializzazione degli oggetti membri.