Gestione delle eccezioni in C ++

Esistono tre tipi di errori software. Questi sono errori di sintassi, errori logici ed errori di runtime.

Errori di sintassi

Un'espressione, un'istruzione o una costruzione in modo errato è un errore di sintassi.

Considera le seguenti due dichiarazioni:

int arr [] = 1, 2, 3; //corretto
int arr = 1, 2, 3; // errore di sintassi, mancante []

Sono definizioni dello stesso array. Il primo è corretto. Il secondo manca [], e questo è un errore di sintassi. Un programma con un errore di sintassi non riesce a compilare. La compilazione non riesce con un messaggio di errore che indica l'errore di sintassi. La cosa buona è che un errore di sintassi può sempre essere risolto se il programmatore sa cosa sta facendo.

Errore logico

Un errore logico è un errore commesso dal programmatore quando viene effettuata una codifica logica sbagliata. Potrebbe essere il risultato dell'ignoranza dal programmatore alle caratteristiche del linguaggio di programmazione o di un malinteso di ciò che il programma dovrebbe fare.

In questa situazione, il programma viene compilato con successo. Il programma funziona bene, ma produce risultati errati. Un tale errore può essere dovuto a fare un ciclo iterare 5 volte quando viene fatto per iterare 10 volte. Può anche essere che un ciclo sia inconsciamente fatto per iterare infinitamente. L'unico modo per risolvere questo tipo di errore è fare un'attenta programmazione e testare accuratamente il programma prima di consegnarlo al cliente.

Errori di runtime

Input errati o eccezionali causano errori di runtime. In questo caso, il programma è stato compilato con successo e funziona bene in molte situazioni. In alcune situazioni, il programma si arresta in modo anomalo (e si ferma).

Immagina che in un segmento di codice del programma, 8 debba essere diviso per un numero di denominatori. Quindi se il numeratore 8 è diviso per il denominatore 4, la risposta (quoziente) sarebbe 2. Tuttavia, se l'utente inserisce 0 come denominatore, il programma si bloccherebbe. La divisione per 0 non è consentita in matematica e non è anche consentita nel calcolo. Divisione per zero dovrebbe essere prevenuta nella programmazione. La gestione delle eccezioni gestisce gli errori di runtime, come divisione per zero. Il seguente programma mostra come gestire il problema di divisione per zero senza utilizzare la funzione di eccezione in C ++:

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

int numeratore = 8;
Int denominatore = 2;
Se (denominatore != 0)

int risultato = numeratore/denominatore;
cout << result << '\n';

altro

cout << "Division by zero is not permitted!" << '\n';

restituzione 0;

L'output è 4. Se il denominatore fosse 0, l'output sarebbe stato:

“La divisione per zero non è consentita!"

Il codice principale qui è un costrutto if-else. Se il denominatore non è 0, la divisione avrà luogo; Se è 0, la divisione non avverrà. Verrà inviato un messaggio di errore all'utente e il programma continua a funzionare senza arrestare. Gli errori di runtime vengono generalmente gestiti evitando l'esecuzione di un segmento di codice e inviando un messaggio di errore all'utente.

La funzione di eccezione in C ++ utilizza un blocco try per il blocco if e un blocco per il blocco else per gestire l'errore, proprio come segue:

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

int numeratore = 8;
Int denominatore = 2;
Tentativo

Se (denominatore != 0)

int risultato = numeratore/denominatore;
cout << result << '\n';

altro

lanciare 0;


cattura (int err)

if (err == 0)
cout << "Division by zero is not permitted!" << '\n';

restituzione 0;

Si noti che l'intestazione di prova non ha un argomento. Si noti inoltre che il blocco di cattura, che è come una definizione di funzione, ha un parametro. Il tipo di parametro deve essere lo stesso dell'operando (argomento) dell'espressione di lancio. L'espressione di lancio è nel blocco del tentativo. Lancia un argomento della scelta del programmatore correlato all'errore e il blocco lo prende. In questo modo, il codice nel blocco del tentativo non viene eseguito. Quindi, il blocco di cattura visualizza il messaggio di errore.

Questo articolo spiega la gestione delle eccezioni in C++. La conoscenza di base in C ++ è un prerequisito per il lettore per capire questo articolo.

Contenuto dell'articolo:

• Funzione che lancia un'eccezione
• Più di un blocco di cattura per un blocco di prova
• I blocchi di prova/cattura nidificati
• Specificatore noxcept
• La funzione speciale std :: termini ()
• Conclusione

Funzione che lancia un'eccezione:

Una funzione può anche lanciare un'eccezione proprio come fa il blocco del tentativo. Il lancio avviene all'interno della definizione della funzione. Il seguente programma illustra questo:

#includere
Utilizzo dello spazio dei nomi std;
void fn (const char* str)

if (islower (str [0]))
lanciare 'l';

int main ()

Tentativo

fn ("Smith");

Catch (Char Ch)

if (ch == 'l')
cout << "Person's name cannot begin in lowercase!" << '\n';

restituzione 0;

Si noti che questa volta, il blocco di prova ha solo la chiamata di funzione. È la funzione chiamata che ha l'operazione di lancio. Il blocco catch cattura l'eccezione e l'output è:

“Il nome della persona non può iniziare in minuscolo!"

Questa volta, il tipo lanciato e catturato è un carbone.

Più di un blocco di cattura per un blocco di prova:

Può esserci più di un blocco di cattura per un blocco di prova. Immagina la situazione in cui un input può essere uno qualsiasi dei caratteri della tastiera, ma non una cifra e non un alfabeto. In questo caso, ci devono essere due blocchi di cattura: uno per un numero intero per controllare la cifra e uno per un carbone per controllare l'alfabeto. Il seguente codice illustra questo:

#includere
Utilizzo dello spazio dei nomi std;
char input = '*';
int main ()

Tentativo

if (isdigit (input))
lanciare 10;
if (isalpha (input))
lanciare 'z';

catch (int)

cout << "Digit input is forbidden!" << '\n';

Catch (Char)

cout << "Character input is forbidden!" << '\n';

restituzione 0;

Non c'è output. Se il valore dell'input era una cifra, E.G., '1', l'output sarebbe stato:

"L'input di cifre è vietato!"

Se il valore dell'input era un alfabeto, E.G., 'A', l'output sarebbe stato:

"L'input del personaggio è proibito!"

Si noti che nell'elenco dei parametri dei due blocchi di cattura, non esiste un nome identificativo. Si noti inoltre che nella definizione dei due blocchi di cattura, gli argomenti particolari lanciati non sono stati verificati se i loro valori sono esatti o meno.

Ciò che conta per un problema è il tipo; Un problema deve corrispondere al tipo di operando lanciato. Il valore particolare dell'argomento (operando) lanciato può essere utilizzato per un'ulteriore verifica, se necessario.

Più di un gestore per lo stesso tipo

È possibile avere due gestori dello stesso tipo. Quando viene lanciata un'eccezione, il controllo viene trasferito al gestore più vicino con un tipo di abbinamento. Il seguente programma illustra questo:

#includere
Utilizzo dello spazio dei nomi std;
char input = '1';
int main ()

Tentativo

if (isdigit (input))
lanciare 10;

catch (int)

cout << "Digit input is forbidden!" << '\n';

catch (int)

cout << "Not allowed at all: digit input!" << '\n';

restituzione 0;

L'output è:

"L'input di cifre è vietato!"

Blocchi di prova/cattura nidificati:

I blocchi di prova/cattura possono essere nidificati. Il programma di cui sopra per l'input di caratteri non alfanumerici dalla tastiera viene ripetuto qui, ma con il codice di errore alfabetico nidificato:

#includere
Utilizzo dello spazio dei nomi std;
char input = '*';
int main ()

Tentativo

if (isdigit (input))
lanciare 10;
Tentativo

if (isalpha (input))
lanciare 'z';

Catch (Char)

cout << "Character input is forbidden!" << '\n';


catch (int)

cout << "Digit input is forbidden!" << '\n';

restituzione 0;

L'errore alfabetico tentativo/blocco di cattura è nidificato nel blocco del codice cifre. Il funzionamento di questo programma e l'operazione precedente da cui viene copiato sono gli stessi.

Specificatore noxcept

Considera la seguente funzione:

void fn (const char* str) noxcept

if (islower (str [0]))
lanciare 'l';

Si noti che lo specificatore "NoExcept" subito dopo la parentesi giusta dell'elenco dei parametri della funzione. Ciò significa che la funzione non dovrebbe lanciare un'eccezione. Se la funzione lancia un'eccezione, come in questo caso, si compilerà con un messaggio di avviso ma non eseguirà. Un tentativo di eseguire il programma chiamerà la funzione speciale std :: terminazione (), che dovrebbe fermare il programma con grazia invece di permettergli solo di crash letteralmente.

Lo specificatore NoExcept si trova in forme diverse. Questi sono i seguenti:

tipo func () noexcept; : non consente un'espressione di lancio
tipo func () noexcept (true); : consente un'espressione di lancio
tipo func () throw (); : non consente un'espressione di lancio
tipo func () noexcept (false); : consente un'espressione di lancio, che è facoltativa
tipo func (); : consente un'espressione di lancio, che è facoltativa

vero o falso tra le parentesi possono essere sostituiti da un'espressione che si traduce in vero o falso.

La funzione speciale std :: termini ():

Se un'eccezione non può essere gestita, dovrebbe essere rimborsata. In questo caso, l'espressione lanciata può o meno avere un operando. La funzione speciale std :: terminazione () sarà chiamata in fase di esecuzione, che dovrebbe fermare il programma con grazia invece di permettergli solo di crash letteralmente.

Digita, compila ed esegui il seguente programma:

#includere
Utilizzo dello spazio dei nomi std;
char input = '1';
int main ()

Tentativo

if (isdigit (input))
lanciare 10;

catch (int)

gettare;

restituzione 0;

Dopo una raccolta di successo, il programma terminato senza eseguire e il messaggio di errore dal computer dell'autore è:

"Termina chiamata dopo aver lanciato un'istanza di" int "

Abortito (core scaricato) "

Conclusione:

La funzione di eccezione in C ++ impedisce l'esecuzione di un segmento di codice in base a un qualche tipo di input. Il programma continua a eseguire se necessario. L'eccezione (prevenzione degli errori) è costituito da un blocco di prova e un blocco di cattura. Il blocco del tentativo ha il segmento di codice di interesse, che può essere bypassato, a seconda di alcune condizioni di input. Il blocco del tentativo ha l'espressione di lancio, che lancia un operando. Questo operando è anche chiamato l'eccezione. Se il tipo di operando e il tipo per il parametro del blocco catch sono uguali, l'eccezione viene catturata (gestita). Se l'eccezione non viene catturata, il programma verrà chiuso, ma comunque, essere sicuro poiché il segmento di codice che doveva essere eseguito per dare il risultato errata non è stato eseguito. Gestione delle eccezioni tipica significa bypassare il segmento di codice e inviare un messaggio di errore all'utente. Il segmento del codice viene eseguito per l'input normale ma bypassato per input errati.