Istruzioni try, throw e catch (C++)

Per implementare la gestione delle eccezioni in C++, usare tryle espressioni , throwe catch .

Usare prima di tutto un try blocco per racchiudere una o più istruzioni che potrebbero generare un'eccezione.

Un'espressione throw segnala che una condizione eccezionale, spesso, si è verificato un errore in un try blocco. È possibile usare 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 usare la std::exception classe o una delle classi derivate definite nella libreria standard. Se uno di questi non è appropriato, è consigliabile derivare la propria classe di eccezione da std::exception.

Per gestire le eccezioni che possono essere generate, implementare uno o più catch blocchi immediatamente dopo un try blocco. Ogni catch blocco specifica il tipo di eccezione che può gestire.

Questo esempio mostra un try blocco e 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 rilevate per const riferimento 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");
   // ...
}

Osservazioni:

Il codice dopo la try clausola è la sezione sorvegliata del codice. L'espressione throw genera, ovvero genera, un'eccezione. Il blocco di codice dopo la catch clausola è il gestore eccezioni. Si tratta del gestore che intercetta l'eccezione generata se i tipi nelle throw espressioni e catch sono compatibili. Per un elenco di regole che regolano la corrispondenza dei tipi nei catch blocchi, vedere Come vengono valutati i blocchi catch. Se l'istruzione catch specifica i puntini di sospensione (...) anziché un tipo, il catch blocco gestisce ogni tipo di eccezione. Quando si esegue la compilazione con l'opzione /EHa , questi possono includere eccezioni strutturate C e eccezioni asincrone generate dal sistema o generate dall'applicazione, ad esempio protezione della memoria, divisione per zero e violazioni a virgola mobile. Poiché catch i blocchi vengono elaborati per trovare un tipo corrispondente, un gestore con i puntini di sospensione deve essere l'ultimo gestore per il blocco associato try . Prestare catch(...) attenzione. Non consentire a un programma di continuare, a meno che il blocco catch non sappia come gestire l'eccezione specifica rilevata. 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 che non ha alcun operando genera nuovamente l'eccezione attualmente gestita. È consigliabile usare questo modulo quando si rigenera l'eccezione, perché mantiene le informazioni sul tipo polimorfico dell'eccezione originale. Tale espressione deve essere usata solo in un catch gestore o in una funzione chiamata da un catch gestore. L'oggetto eccezione rethrown è 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;
}

Vedi anche

Procedure consigliate C++ moderne per le eccezioni e la gestione degli errori
Parole chiave
Eccezioni C++ non gestite
__uncaught_exception