Una volta sono stato avvisato che un programma C ++ dovrebbe alla fine catturare tutte le eccezioni. Il ragionamento fornito all'epoca era essenzialmente che i programmi che consentono alle eccezioni di espandersi al di fuori di main() entrano in uno strano stato zombie. Mi è stato detto questo diversi anni fa e, a posteriori, credo che il fenomeno osservato sia dovuto alla lunga generazione di dump core eccezionalmente grandi dal progetto in questione.
All'epoca questo sembrava strano ma convincente. Era del tutto assurdo che C ++ dovesse "punire" i programmatori per non aver colto tutte le eccezioni, ma le prove precedenti mi sembravano confermare. Per il progetto in questione, i programmi che lanciavano eccezioni non rilevate sembravano entrare in uno strano stato di zombi - o come sospetto che la causa fosse ora, un processo nel mezzo di un deposito core indesiderato è insolitamente difficile da fermare.
(Per chi si chiede perché questo non era più ovvio in quel momento: il progetto ha generato una grande quantità di output in più file da più processi che oscuravano effettivamente qualsiasi tipo di messaggio aborted (core dumped) e in questo caso particolare, post- L'esame mortem delle core dump non era un'importante tecnica di debug, quindi non ci si era mai preoccupati delle discariche di base: i problemi con un programma di solito non dipendevano dallo stato accumulato da molti eventi nel tempo da un programma longevo, ma dagli input iniziali per un programma di breve durata (< 1 ora) quindi era più pratico eseguire nuovamente un programma con gli stessi input da una build di debug o in un debugger per ottenere maggiori informazioni.)
Al momento, non sono sicuro che esista un vantaggio o uno svantaggio di cattura delle eccezioni solo al fine di impedire che le eccezioni lascino main() .
Il piccolo vantaggio a cui posso pensare di consentire alle eccezioni di risalire oltre main() è che fa sì che il risultato di std::exception::what() venga stampato sul terminale (almeno con i programmi compilati con gcc su Linux). D'altra parte, questo è banale da raggiungere catturando invece tutte le eccezioni derivate da std::exception e stampando il risultato di std::exception::what() e se è opportuno stampare un messaggio da un'eccezione che non deriva da std::exception allora deve essere catturato prima di lasciare main() per stampare il messaggio.
Il modesto svantaggio che posso pensare per consentire alle eccezioni di risalire oltre main() è che possono essere generati dump core indesiderati. Per un processo che utilizza una grande quantità di memoria questo può essere piuttosto fastidioso e il controllo del comportamento di dumping di base da un programma richiede chiamate di funzioni specifiche del sistema operativo. D'altra parte, se si desidera un core dump e exit, questo potrebbe essere ottenuto in qualsiasi momento chiamando std::abort() e un'uscita senza core dump può essere raggiunta in qualsiasi momento chiamando std::exit() .
Aneddoticamente, non penso di aver mai visto il messaggio predefinito what(): ... stampato da un programma ampiamente distribuito al momento del crash.
Quali sono gli argomenti forti a favore o contro che consentono alle eccezioni del C ++ di risalire oltre main() ?
Modifica: ci sono molte domande generali sulla gestione delle eccezioni su questo sito. La mia domanda riguarda specificamente le eccezioni C ++ che non possono essere gestite e sono arrivate fino a main() - forse è possibile stampare un messaggio di errore ma è un errore di interruzione immediato.