Gestione delle eccezioni C ++: prova, cattura, lancia l'esempio

Che cos'è la gestione delle eccezioni in C ++?

La gestione delle eccezioni in C ++ fornisce un modo per gestire circostanze impreviste come gli errori di runtime. Pertanto, ogni volta che si verifica una circostanza imprevista, il controllo del programma viene trasferito a funzioni speciali note come gestori.

Per catturare le eccezioni, posizionare alcune sezioni di codice sotto il controllo delle eccezioni. La sezione di codice viene inserita nel blocco try-catch.

Se si verifica una situazione eccezionale all'interno di quella sezione di codice, verrà generata un'eccezione. Successivamente, il gestore delle eccezioni assumerà il controllo del programma.

Nel caso in cui non si verifichino circostanze eccezionali, il codice verrà eseguito normalmente. I gestori verranno ignorati.

In questo tutorial C ++ imparerai:

Che cos'è la gestione delle eccezioni in C ++?
Perché la gestione delle eccezioni?
Parole chiave per la gestione delle eccezioni
Sintassi:
Eccezioni standard C ++
Eccezioni definite dall'utente

Perché la gestione delle eccezioni?

Ecco i motivi per utilizzare la gestione delle eccezioni in C ++:

Separerai il codice di gestione degli errori dal codice normale. Il codice sarà più leggibile e più facile da mantenere.
Le funzioni possono gestire le eccezioni che scelgono. Anche se una funzione genera molte eccezioni, ne gestirà solo alcune. Il chiamante gestirà le eccezioni non rilevate.

Parole chiave per la gestione delle eccezioni

La gestione delle eccezioni in C ++ ruota attorno a queste tre parole chiave:

lancia : quando un programma incontra un problema, genera un'eccezione. La parola chiave throw aiuta il programma a eseguire il lancio.
catch : un programma utilizza un gestore di eccezioni per catturare un'eccezione. Viene aggiunto alla sezione di un programma in cui è necessario gestire il problema. È fatto usando la parola chiave catch.
try : il blocco try identifica il blocco di codice per il quale verranno attivate determinate eccezioni. Dovrebbe essere seguito da uno / più blocchi di cattura.

Supponiamo che un blocco di codice sollevi un'eccezione. L'eccezione verrà rilevata da un metodo che utilizza le parole chiave try and catch. Il blocco try / catch dovrebbe racchiudere il codice che potrebbe generare un'eccezione. Tale codice è noto come codice protetto.

Sintassi:

Il try / catch accetta questa sintassi:

try {// the protected code} catch( Exception_Name exception1 ) {// catch block} catch( Exception_Name exception2 ) {// catch block} catch( Exception_Name exceptionN ) {// catch block}

Sebbene abbiamo una dichiarazione try, possiamo avere molte dichiarazioni catch.
ExceptionName è il nome dell'eccezione da intercettare.
L'eccezione1, l'eccezione2 e l'eccezioneN sono i nomi definiti per fare riferimento alle eccezioni.

Esempio 1:

#include#includeusing namespace std;int main() {vector vec;vec.push_back(0);vec.push_back(1);// access the third element, which doesn't existtry{vec.at(2);}catch (exception& ex){cout << "Exception occurred!" << endl;}return 0;}

Produzione:

Ecco uno screenshot del codice:

Spiegazione del codice:

Includere il file di intestazione iostream nel programma per utilizzare le sue funzioni.
Includere il file di intestazione del vettore nel programma per utilizzare le sue funzioni.
Includere lo spazio dei nomi std nel programma nelle sue classi senza chiamarlo.
Chiama la funzione main (). La logica del programma dovrebbe essere aggiunta all'interno del suo corpo.
Crea un vettore denominato vec per memorizzare i dati interi.
Aggiungi l'elemento 0 al vettore denominato vec.
Aggiungi l'elemento 1 al vettore denominato vec.
Un commento. Verrà ignorato dal compilatore C ++.
Utilizzare l'istruzione try per rilevare un'eccezione. La {segna l'inizio del corpo del blocco try / catch. Il codice aggiunto all'interno del corpo diventerà il codice protetto.
Prova ad accedere all'elemento memorizzato all'indice 2 (terzo elemento) del vettore denominato vec. Questo elemento non esiste.
Fine del corpo del blocco try / catch.
Cattura l'eccezione. Il messaggio di errore restituito verrà memorizzato nella variabile ex.
Stampa un messaggio sulla console se l'eccezione viene rilevata.
Fine del corpo del blocco di cattura.
Il programma dovrebbe restituire un valore in caso di corretta esecuzione.
Fine del corpo della funzione main ().

Esempio 2:

#include using namespace std;double zeroDivision(int x, int y) {if (y == 0) {throw "Division by Zero!";}return (x / y);}int main() {int a = 11;int b = 0;double c = 0;try {c = zeroDivision(a, b);cout << c << endl;}catch (const char* message) {cerr << message << endl;}return 0;}

Produzione:

Ecco uno screenshot del codice:

Spiegazione del codice:

Includere il file di intestazione iostream nel programma per utilizzare le sue funzioni.
Includere lo spazio dei nomi std nel programma nelle sue classi senza chiamarlo.
Crea una funzione denominata zeroDivision che accetta due argomenti interi, x e y. La funzione dovrebbe restituire un doppio risultato.
Utilizzare un'istruzione if per verificare se il valore dell'argomento della variabile y è 0. La {segna l'inizio del corpo if.
Il messaggio da restituire / lanciare se y è 0.
Fine del corpo dell'istruzione if.
La funzione zeroDivision dovrebbe restituire il valore di x / y.
Fine del corpo della funzione zeroDivision.
Chiama il metodo main (). La {segna l'inizio di questo metodo.
Dichiarare una variabile intera e assegnarle il valore 11.
Dichiarare una variabile intera be assegnandole il valore 0.
Dichiarare una doppia variabile ce assegnandole il valore 0.
Utilizzare l'istruzione try per rilevare un'eccezione. La {segna l'inizio del corpo del blocco try / catch. Il codice aggiunto all'interno del corpo diventerà il codice protetto.
Chiama la funzione zeroDivision e passa agli argomenti aeb, ovvero 11 e 0. Il risultato di questa operazione verrà memorizzato nella variabile c.
Stampa il valore della variabile c sulla console.
Fine del corpo del blocco try / catch.
Cattura l'eccezione. Il messaggio di errore restituito verrà memorizzato nel messaggio variabile.
Stampa il messaggio di errore restituito sulla console.
Fine del corpo del blocco di cattura.
Il programma dovrebbe restituire un valore in caso di corretta esecuzione.
Fine del corpo della funzione main ().

Eccezioni standard C ++

C ++ viene fornito con un elenco di eccezioni standard definite nella classe . Questi sono descritti di seguito:

Eccezione	Descrizione
std :: eccezione	Questa è un'eccezione e la classe genitore di tutte le eccezioni C ++ standard.
std :: bad_alloc	Questa eccezione viene generata da una nuova parola chiave.
std :: bad_cast	Questa è un'eccezione lanciata da dynamic_cast.
std :: bad_exception	Un dispositivo utile per gestire le eccezioni impreviste nei programmi C ++.
std :: bad_typeid	Eccezione generata da typeid.
std :: logic_error	Questa eccezione è teoricamente rilevabile leggendo il codice.
std :: errore_dominio	Questa è un'eccezione generata dopo aver utilizzato un dominio matematicamente non valido.
std :: argomento_valido	Eccezione generata per l'utilizzo di argomenti non validi.
std :: length_error	Un'eccezione generata dopo la creazione di un grande std :: string.
std :: out_of_range	Gettato dal metodo.
std :: runtime_error	Questa è un'eccezione che non può essere rilevata tramite la lettura del codice.
std :: overflow_error	Questa eccezione viene generata dopo il verificarsi di un overflow matematico.
std :: range_error	Questa eccezione viene generata quando si tenta di memorizzare un valore fuori intervallo.
std :: underflow_error	Eccezione generata dopo il verificarsi di underflow matematico.

Eccezioni definite dall'utente

La classe C ++ std :: exception ci permette di definire oggetti che possono essere lanciati come eccezioni. Questa classe è stata definita nell'intestazione . La classe ci fornisce una funzione membro virtuale denominata what.

Questa funzione restituisce una sequenza di caratteri con terminazione null di tipo char *. Possiamo sovrascriverlo nelle classi derivate per avere una descrizione dell'eccezione.

Esempio:

#include #include using namespace std;class newException : public exception{virtual const char* what() const throw(){return "newException occurred";}} newex;int main() {try {throw newex;}catch (exception& ex) {cout << ex.what() << '\n';}return 0;}

Produzione:

Ecco uno screenshot del codice:

Spiegazione del codice:

Includere il file di intestazione iostream nel nostro programma. Useremo le sue funzioni senza ottenere errori.
Includere il file di intestazione dell'eccezione nel nostro programma. Useremo le sue funzioni come cosa senza errori.
Includere lo spazio dei nomi std nel nostro programma per utilizzare le sue classi senza chiamarlo.
Crea una nuova classe denominata newException. Questa classe eredita la classe di eccezione di C ++.
L'inizio del corpo della classe.
Sovrascrivi la funzione membro virtuale what () definita nel file di intestazione dell'eccezione. Descriveremo quindi la nostra eccezione, la nuova eccezione.
Inizia la definizione della nuova eccezione.
Il messaggio da restituire se la nuova eccezione viene rilevata.
Fine della definizione della nuova eccezione.
Fine del corpo della classe newException. Newex è il nome da utilizzare per catturare la nostra nuova eccezione, dopodiché verrà chiamata newException.
Chiama la funzione main (). La logica del programma dovrebbe essere aggiunta all'interno del suo corpo. La {segna l'inizio del suo corpo.
Utilizzare un'istruzione try per contrassegnare il codice all'interno del quale è necessario contrassegnare l'eccezione. La {segna l'inizio del corpo del blocco try / catch. Il codice circondato da questo verrà protetto.
Lancia l'eccezione newex se viene rilevata.
Fine del corpo di prova.
Usa l'istruzione catch per catturare l'eccezione. Il messaggio di errore di eccezione verrà memorizzato nella variabile ex.
Stampa il messaggio di errore di eccezione sulla console.
Fine del corpo della dichiarazione di cattura.
Il programma dovrebbe restituire un valore se viene eseguito correttamente.
Fine del corpo della funzione main ().

Sommario:

Con la gestione delle eccezioni in C ++, puoi gestire gli errori di runtime.
Gli errori di runtime sono gli errori che si verificano durante l'esecuzione del programma.
La gestione delle eccezioni ti aiuta a gestire eventuali circostanze impreviste nel tuo programma.
Quando si verifica la circostanza imprevista, il controllo del programma viene trasferito ai gestori.
Per catturare un'eccezione, inserisci una sezione di codice sotto il blocco try-catch.
La parola chiave throw aiuta il programma a lanciare eccezioni, aiutando il programma a gestire il problema.
La parola chiave try aiuta a identificare il blocco di codice per il quale verranno attivate determinate eccezioni.
Possiamo sovrascrivere la funzione what () del file di intestazione delle eccezioni per definire le nostre eccezioni.