Una volta mi è stato consigliato che un programma C ++ dovrebbe alla fine catturare tutte le eccezioni. Il ragionamento fornito all'epoca era essenzialmente che i programmi che consentivano alle eccezioni di emergere fuori da main()uno strano stato di zombi. Mi è stato detto questo diversi anni fa e, a posteriori, credo che il fenomeno osservato fosse dovuto alla lunga generazione di discariche core eccezionalmente grandi dal progetto in questione.
All'epoca sembrava bizzarro ma convincente. Era del tutto assurdo che il C ++ "punisse" i programmatori per non aver colto tutte le eccezioni, ma le prove che avevo davanti sembravano confermarlo. Per il progetto in questione, i programmi che generavano eccezioni non rilevate sembravano entrare in uno strano stato di zombi - o come sospetto che la causa fosse ora, un processo nel mezzo di una discarica di core indesiderata è insolitamente difficile da fermare.
(Per chiunque si chiedesse perché questo non fosse più ovvio al momento: il progetto ha generato una grande quantità di output in più file da più processi che hanno effettivamente oscurato qualsiasi tipo di aborted (core dumped)messaggio e in questo caso particolare, l'esame post mortem dei dump core non era si tratta di un'importante tecnica di debug, quindi non è stata data molta importanza ai dump principali. I problemi con un programma di solito non dipendevano dallo stato accumulato da molti eventi nel tempo da un programma di lunga durata ma piuttosto dagli input iniziali di un programma di breve durata (< 1 ora) quindi è stato più pratico rieseguire 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 grande vantaggio o svantaggio nel catturare le eccezioni al solo scopo di impedire che le eccezioni vadano via main().
Il piccolo vantaggio che mi viene in mente per consentire il superamento delle eccezioni main()è che provoca la std::exception::what()stampa del risultato sul terminale (almeno con i programmi compilati da gcc su Linux). D'altra parte, questo è banale da ottenere invece catturando tutte le eccezioni derivate da std::exceptione stampando il risultato std::exception::what()e se è desiderabile stampare un messaggio da un'eccezione che non deriva da std::exceptionallora deve essere catturato prima di partire main()per stampare il messaggio.
Lo svantaggio modesto che mi viene in mente per consentire alle eccezioni di superare il passato main()è che possono essere generati dump core indesiderati. Per un processo che utilizza una grande quantità di memoria, ciò può essere piuttosto fastidioso e il controllo del comportamento di dumping principale da un programma richiede chiamate di funzione specifiche del sistema operativo. D'altra parte, se si desidera un dump e un'uscita core, questo potrebbe invece essere raggiunto in qualsiasi momento chiamando std::abort()e un'uscita senza dump core può essere raggiunta in qualsiasi momento chiamando std::exit().
Aneddoticamente, non credo di aver mai visto il what(): ...messaggio predefinito stampato da un programma ampiamente distribuito dopo un crash.
Quali sono, se ve ne sono, gli argomenti forti a favore o contro il fatto che le eccezioni C ++ saltino fuori main()?
Modifica: ci sono molte domande generali sulla gestione delle eccezioni su questo sito. La mia domanda riguarda in particolare le eccezioni C ++ che non possono essere gestite e sono riuscite fino in fondo main()- forse un messaggio di errore può essere stampato ma è un errore di arresto della visualizzazione immediata.