Istruzioni try, throw e catch (C++)
Per implementare la gestione delle eccezioni in C++, utilizzare le espressioni try, throw e catch.
In primo luogo, utilizzare un blocco try per contenere una o più istruzioni che potrebbero generare un'eccezione.
Un'espressione throw segnala che una condizione eccezionale, spesso un errore, si è verificata in un blocco try. È possibile utilizzare un oggetto di qualsiasi tipo come operando di un'espressione throw. Questo oggetto viene in genere utilizzato per comunicare informazioni sull'errore. Nella maggior parte dei casi è consigliabile utilizzare la classe std::exception o una delle classi derivate definite nella libreria standard. Se una di queste classi non è appropriata, è consigliabile derivare una propria classe di eccezione da std::exception.
Per gestire le eccezioni che potrebbero essere generate, implementare uno o più blocchi catch immediatamente dopo un blocco try. Ogni blocco catch specifica il tipo di eccezione che può gestire.
In questo esempio viene mostrato un blocco try con i relativi gestori. Si supponga che GetNetworkResource() acquisisca dati su una connessione di rete e che i due tipi di eccezione siano classi definite dall'utente che derivano da std::exception. Si noti che le eccezioni vengono intercettate dal riferimento const nell'istruzione catch. È consigliabile generate eccezioni per valore e intercettarle per riferimento const.
Esempio
MyData md;
try {
// Code that could throw an exception
md = GetNetworkResource();
}
catch (const networkIOException& e) {
// Code that executes when an exception of type
// networkIOException is thrown in the try block
// ...
// Log error message in the exception object
cerr << e.what();
}
catch (const myDataFormatException& e) {
// Code that handles another exception type
// ...
cerr << e.what();
}
// The following syntax shows a throw expression
MyData GetNetworkResource()
{
// ...
if (IOSuccess == false)
throw networkIOException("Unable to connect");
// ...
if (readError)
throw myDataFormatException("Format error");
// ...
}
Note
Il codice dopo la clausola try è la sezione protetta. L'espressione throw genera un'eccezione. Il blocco di codice dopo la clausola catch rappresenta il gestore dell'eccezione. Si tratta del gestore che intercetta l'eccezione generata se i tipi nelle espressioni catch e throw sono compatibili. Per un elenco di regole che regolano la corrispondenza dei tipi nei blocchi catch, vedere Modalità di valutazione dei blocchi catch (C++). Se l'istruzione catch specifica i puntini di sospensione (...) anziché un tipo, il blocco catch gestisce ogni tipo di eccezione. Quando si esegue la compilazione con l'opzione /EHa, sono incluse le eccezioni strutturate C e le eccezioni asincrone generate dal sistema o dall'applicazione, ad esempio protezione della memoria, divisione per zero e violazioni a virgola mobile. Poiché i blocchi catch vengono elaborati nell'ordine del programma per trovare un tipo corrispondente, un gestore puntini di sospensione deve essere l'ultimo gestore per il blocco try associato. Utilizzare con cautela catch(...). Non consentire a un programma di proseguire a meno che il blocco catch non sia in grado di gestire l'eccezione specifica intercettata. Un blocco catch(...) viene in genere utilizzato per registrare gli errori ed eseguire una pulizia speciale prima che l'esecuzione del programma venga interrotta.
Un'espressione throw priva di operando rigenera l'eccezione attualmente gestita. È consigliabile utilizzare questo formato quando si rigenera l'eccezione, perché mantiene le informazioni sul tipo polimorfico dell'eccezione generale. Un'espressione di questo tipo deve essere utilizzata solo in un gestore catch o in una funzione chiamata da un gestore catch. L'oggetto eccezione generato nuovamente è l'oggetto eccezione originale, non una copia.
try {
throw CSomeOtherException();
}
catch(...) {
// Catch all exceptions – dangerous!!!
// Respond (perhaps only partially) to the exception, then
// re-throw to pass the exception to some other handler
// ...
throw;
}