Eccezioni C++ non gestite

Question

Il C++ offre un modo per "mostrare" qualcosa di visivo se si verifica un'eccezione non gestita?

Quello che voglio fare è quello di fare qualcosa di simile assert(unhandled exception.msg()) se effettivamente accade (come nel seguente esempio):

void foo() { 
    throw std::exception("Message!"); 
} 

int main() { 
foo(); 
} 

Mi aspetto che questo tipo di codice non per la terminazione (perché eccezione è stata gestita), piuttosto mostra un messaggio di asserzione personalizzato (Message!).

È possibile?

Answer 1

Non c'è modo specificato dallo standard per visualizzare in realtà il messaggio del eccezione non rilevata. Tuttavia, su molte piattaforme, è comunque possibile. Su Windows, è possibile utilizzare SetUnhandledExceptionFilter ed estrarre le informazioni sull'eccezione C++.Con g ++ (versioni appropriate di ogni caso), il gestore può accedere interrompere l'eccezione non rilevata con un codice simile:

void terminate_handler() 
    { 
     try { throw; } 
     catch(const std::exception& e) { log(e.what()); } 
     catch(...) {} 
    } 

anzi g 's ++ predefinito interrompere gestore fa qualcosa di simile a questo. È possibile impostare il gestore di terminazione con set_terminate.

In breve, non c'è un modo generico in C++, ma ci sono modi in base alla piattaforma.

Answer 2

Se sto leggendo correttamente la tua domanda, stai chiedendo se è possibile sovraccaricare throw (cambiando il suo comportamento predefinito) in modo che faccia qualcosa definito dall'utente. No, non puoi.

Edit: visto che sei insistente :), ecco una cattiva idea ™:

#include <iostream> 
#include <stdlib.h> 
#include <windows.h> 

void monkey() { 
    throw std::exception("poop!"); 
} 

LONG WINAPI MyUnhandledExceptionFilter(struct _EXCEPTION_POINTERS *lpTopLevelExceptionFilter) { 
    std::cout << "poop was thrown!" << std::endl; 
    return EXCEPTION_EXECUTE_HANDLER; 
    } 

int main() { 
    SetUnhandledExceptionFilter(&MyUnhandledExceptionFilter); 
    monkey(); 
    return 1; 
} 

Ancora una volta, questa è una pessima idea, ed è, ovviamente, dipende dalla piattaforma, ma funziona.

Answer 3

Microsoft Visual C++ consente di agganciare eccezioni C++ non gestite like this. Questo è standard STL behaviour.

È possibile impostare un gestore tramite una chiamata a set_terminate. È consigliabile che il gestore non funzioni molto e quindi interrompa il programma, ma non vedo perché non è possibile segnalare qualcosa tramite un'asserzione, sebbene non si abbia accesso all'eccezione che ha causato il problema.

Answer 4

Se si utilizza Windows, una buona libreria per la gestione di eccezioni non gestite e arresti anomali è CrashRpt. Se vuoi farlo manualmente, puoi anche use the following I wrote in this answer.

Answer 5

penso che si dovrebbe beneficiare di un catch-all economico come segue:

int main() { 
try { 
    foo(); 
catch (...) { 
    // Do something with the unhandled exception. 
} 
} 

Answer 6

Sì, la sua possibile. Qui si va:

#include <iostream> 
#include <exception> 

void foo() 
{ 
    throw std::exception("Message!"); 
} 

int main() 
{ 
    try 
    { 
    foo(); 
    } 
    catch (std::exception& e) 
    { 
    std::cout << "Got exception: " << e.what() << std::endl; 
    } 

    return 0; 
} 

Answer 7

Lo standard C++ è il gestore di sospendere - come altri hanno detto

Se siete dopo una migliore rintracciabilità per tiri allora questo è quello che facciamo

Abbiamo un tiro macro che registra il nome del file e il numero della linea e il messaggio e poi getta. Richiede un messaggio varargs in stile printf.

Throw(proj::FooException, "Fingle %s unable to process bar %d", fingle.c_str(), barNo); 

ottengo un bel messaggio di log

Throw FooException from nargle.cpp:42 Fingle barf is unable to process bar 99 

Answer 8

Se sei davvero interessato a ciò che è accaduto per far fallire il tuo programma, potresti trarre vantaggio dall'esame dell'immagine del processo in un debugger post-mortem. La tecnica precisa varia un po 'dal sistema operativo al sistema operativo, ma il treno di base è innanzitutto abilitare il dumping del nucleo e compilare il programma con i simboli di debug. Una volta che il programma si blocca, il sistema operativo copia la sua memoria su disco e puoi esaminare lo stato del programma nel momento in cui si è arrestato.