Gestione delle eccezioni C ++

L'eccezione è un comportamento anormale o un errore di runtime. L'eccezione è una situazione insolita nel nostro programma in cui il nostro programma dovrebbe essere pronto a gestirlo con una risposta appropriata.

Dove si verifica l'eccezione

Ogni volta che eseguiamo qualsiasi software, prevediamo che il nostro software funzioni correttamente in qualsiasi situazione. Ma in alcuni casi, alcuni eventi si verificano quando viene fermato il normale flusso di esecuzione del nostro software. Quindi, quando diciamo che il nostro software deve essere robusto, significa che il software funziona correttamente in qualsiasi situazione.

La gestione delle eccezioni

La gestione delle eccezioni C ++ viene utilizzata per gestire sistematicamente la condizione di errore in un programma intraprendendo l'azione necessaria. Usando la gestione delle eccezioni, possiamo facilmente gestire e rispondere all'errore di runtime.

Prova, prendi, lancia

1. Se si verifica una situazione eccezionale nel nostro programma, lo conteniamo in un blocco chiamato Tentativo bloccare.
2. Se si verifica un'eccezione all'interno del blocco di prova, deve essere lanciato usando la parola chiave gettare.
3. Quell'eccezione è catturata dal presa bloccare. Nel blocco catch viene intrapresa un'azione necessaria per gestire l'eccezione.

Sintassi

Tentativo

Catch (type1 arg)

Catch (type2 arg)

----------
Catch (typen arg)

Spiegazione
In primo luogo, usiamo per scrivere la parola chiave Tentativo. Dopo aver terminato il blocco di prova, dobbiamo scrivere presa blocca immediatamente. Possiamo scrivere più blocchi di cattura in sequenza. Ma dove provare il blocco end, tutti i blocchi di cattura devono essere scritti immediatamente. Se non scriviamo il blocco catch immediato dopo il blocco di prova, può verificarsi un errore. Noi usiamo gettare Parole chiave all'interno del blocco Try.

Esempio di programmazione 1

# includere
Utilizzo dello spazio dei nomi std;
int main ()

cout<< “ Exception Handling Program :” ;
Tentativo
lanciare 30;
cout<< “ \n Try ” ;

catch (int e)
cout<< “ \n Exception no : ” << e ;

cout<< “ \n Testing The Last Line ” ;

Produzione

Spiegazione della programmazione
In questo esempio di programmazione, stiamo cercando di mostrare come si verificano l'eccezione e come gestirla. All'interno della funzione principale dopo aver scritto un'istruzione di output che utilizziamo Tentativo bloccare. Gettare La parola chiave viene utilizzata all'interno del blocco prova. Dopo aver lanciato la parola chiave usiamo un numero 30. Può essere una stringa o un doppio o un galleggiante, qualsiasi costante che possiamo usare. Quindi scriviamo una dichiarazione Cout. Ma questa riga non può essere eseguita dopo l'esecuzione del tiro. Dopo aver terminato il blocco di prova, scriviamo immediatamente Catch Block. All'interno del blocco catch scriviamo la riga (int e). Con l'aiuto di lanciare parole chiave quale valore lanciamo, quel valore arriverà all'interno della variabile E. Dopo aver terminato il blocco catch, scriviamo un'istruzione di output "\ n testando l'ultima riga". Ora, la domanda è quando questa riga verrà eseguita dopo l'istruzione di output all'interno del blocco di cattura?

Regole di tentativo, cattura e blocco

1. Se scriviamo Try Block, dobbiamo scrivere Catch Block.
2. Se scriviamo solo il blocco catch e non scriviamo alcun blocco di prova e lancio, si verificherà un errore.
3. Se scriviamo il blocco di lancio e cattura e non scriviamo alcun blocco di prova, si verificherà un errore.
4. Se scriviamo solo lancia e non scriviamo nessun tentativo di cattura, non si verificherà alcun errore. Significa che possiamo scrivere lanci senza scrivere il blocco di prova.
5. Se scriviamo più blocchi di cattura con diversi tipi di argomenti in sequenza, che il valore del lancio corrisponderà al tipo di argomento di cattura, lo accetterà. Quindi non verrà eseguito nessun altro blocco di cattura. L'esempio di programmazione è riportato di seguito.

Esempio di programmazione 2

# includere
Utilizzo dello spazio dei nomi std;
int main ()

cout<< “ Exception Handling Program :” ;
Tentativo
if (i == 1)
lanciare 1;
if (i == 2)
lanciare 2;
if (i == 3)
lanciare 3;
cout<< “ \n Try ” ;

catch (double e)
cout<< “ \n Exception no : ” << e ;

catch (int e)
cout<< “ \n Exception no : ” << e ;

cout<< “ \n Testing The Last Line ” ;

Produzione

F. Possiamo scrivere più dichiarazioni di tiro in un singolo blocco di prova.

Esempio di programmazione 3

# includere
Utilizzo dello spazio dei nomi std;
int main ()

int i = 3;
cout<< “ Exception Handling Program :” ;
Tentativo
if (i == 1)
lanciare 1;
if (i == 2)
lanciare 2;
if (i == 3)
lanciare 3;
cout<< “ \n Try ” ;

catch (int e)
cout<< “ \n Exception no : ” << e ;

cout<< “ \n Testing The Last Line ” ;

Produzione

G. Possiamo scrivere una dichiarazione di lancio all'interno di un blocco di prova senza dare alcun valore di lancio.

Esempio di programmazione 4

# includere
Utilizzo dello spazio dei nomi std;
int main ()

cout<< “ Exception Handling Program :” ;
int i = 3;
Tentativo
if (i == 3)
gettare ;
cout<< “ \n Try ” ;

catch (int)
cout<< “ \n Exception no : ” ;

cout<< “ \n Testing The Last Line ” ;

Produzione

Spiegazione

Qui scriviamo la parola chiave di lancio senza alcun valore, quindi il programma verrà terminato perché qui non si verifica una corretta gestione delle eccezioni. Di conseguenza, il blocco catch non verrà eseguito. In tempo di compilazione non ci saranno errori. Ma in tempo di esecuzione il programma verrà chiuso con un messaggio "terminare chiamato senza un'eccezione attiva".

Conclusione

Discutendo in dettaglio sulla gestione delle eccezioni, apprendiamo qui che se si verifica una situazione anormale nel nostro programma, il programma dovrà essere pronto a gestire questa situazione anormale.