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

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 questa C++ tutorial, imparerai:

Perché la gestione delle eccezioni?

Ecco il motivo 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

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

• gettare– quando un programma incontra un problema, genera un'eccezione. La parola chiave launch aiuta il programma a eseguire il lancio.
• prendere– un programma utilizza un gestore di eccezioni per catturare un'eccezione. Viene aggiunto alla sezione di un programma in cui è necessario gestire il problema. Viene fatto utilizzando la parola chiave catch.
• prova– il blocco try identifica il blocco di codice per il quale verranno attivate alcune eccezioni. Dovrebbe essere seguito da uno/più blocchi catch.

Supponiamo che un blocco di codice solleverà un'eccezione. L'eccezione verrà rilevata con 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
}

• Anche se abbiamo un'istruzione try, possiamo avere molte istruzioni catch.
• ExceptionName è il nome dell'eccezione da intercettare.
• Eccezione1, eccezione2 ed eccezioneN sono i nomi definiti dall'utente per fare riferimento alle eccezioni.

Esempio 1:

#include<iostream>
#include<vector>
using namespace std;

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

Produzione:

Ecco uno screenshot del codice:

Spiegazione del codice:

1. Includere il file di intestazione iostream nel programma per utilizzarlo funzioni.
2. Includere il file di intestazione vettoriale nel programma per utilizzare le sue funzioni.
3. Include lo spazio dei nomi std nel programma nelle sue classi senza chiamarlo.
4. Chiama la funzione main(). La logica del programma dovrebbe essere aggiunta all'interno del suo corpo.
5. Crea un vettore denominato vec per memorizzare dati interi.
6. Aggiungi l'elemento 0 al vettore chiamato vec.
7. Aggiungi l'elemento 1 al vettore chiamato vec.
8. Un commento. Verrà saltato dal C++ compilatore.
9. Utilizzare l'istruzione try per rilevare un'eccezione. Il segno { segna l'inizio del corpo del blocco try/catch. Il codice aggiunto all'interno del corpo diventerà il codice protetto.
10. Prova ad accedere all'elemento memorizzato nell'indice 2 (terzo elemento) del vettore denominato vec. Questo elemento non esiste.
11. Fine del corpo del blocco try/catch.
12. Cattura l'eccezione. Il messaggio di errore restituito verrà archiviato nella variabile ex.
13. Stampa qualche messaggio sulla console se l'eccezione viene rilevata.
14. Estremità del corpo del blocco di bloccaggio.
15. Il programma dovrebbe restituire un valore dopo l'esecuzione riuscita.
16. Fine del corpo della funzione main().

Esempio 2:

#include <iostream>
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:

1. Includere il file di intestazione iostream nel programma per utilizzare le sue funzioni.
2. Include lo spazio dei nomi std nel programma nelle sue classi senza chiamarlo.
3. Crea una funzione denominata zeroDivision che accetta due argomenti interi, x e y. La funzione dovrebbe restituire un risultato double.
4. Utilizza un'istruzione if per verificare se il valore dell'argomento variabile y è 0. Il segno { segna l'inizio del corpo if.
5. Il messaggio da restituire/lanciare se y è 0.
6. Fine del corpo dell'istruzione if.
7. La funzione zeroDivision dovrebbe restituire il valore di x/y.
8. Fine del corpo della funzione zeroDivision.
9. Chiama il metodo main(). Il { segna l'inizio di questo metodo.
10. Dichiarare una variabile intera assegnandole il valore 11.
11. Dichiarare una variabile intera b assegnandole il valore 0.
12. Dichiarare una variabile double c e assegnarle il valore 0.
13. Utilizzare l'istruzione try per rilevare un'eccezione. Il segno { segna l'inizio del corpo del blocco try/catch. Il codice aggiunto all'interno del corpo diventerà il codice protetto.
14. Chiama la funzione zeroDivision e passa agli argomenti aeb, ovvero 11 e 0. Il risultato di questa operazione verrà archiviato nella variabile c.
15. Stampa il valore della variabile c sulla console.
16. Fine del corpo del blocco try/catch.
17. Cattura l'eccezione. Il messaggio di errore restituito verrà archiviato nella variabile message.
18. Stampa il messaggio di errore restituito sulla console.
19. Estremità del corpo del blocco di bloccaggio.
20. Il programma dovrebbe restituire un valore dopo l'esecuzione riuscita.
21. Fine del corpo della funzione main().

C++ Eccezioni standard

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

Eccezione	Descrizione
std::eccezione	Questa è un'eccezione e la classe genitore di tutti gli standard C++ eccezioni.
std::bad_alloc	Questa eccezione viene generata da una nuova parola chiave.
std::bad_cast	Questa è un'eccezione generata da Dynamic_cast.
std::bad_exception	Un dispositivo utile per gestire le eccezioni impreviste in C++ programmi.
std::bad_typeid	Un'eccezione lanciata da typeid.
std::errore_logico	Questa eccezione è teoricamente rilevabile leggendo il codice.
std::errore_dominio	Questa è un'eccezione generata dopo aver utilizzato un dominio matematicamente non valido.
std::argomento_invalido	Un'eccezione lanciata per l'utilizzo di argomenti non validi.
std::length_error	Un'eccezione lanciata dopo aver creato un grande std::string.
std::fuori_intervallo	Lanciato nel 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	Un'eccezione generata dopo il verificarsi di un underflow matematico.

Eccezioni definite dall'utente

Il C++ La classe std::exception ci consente di definire oggetti che possono essere lanciati come eccezioni. Questa classe è stata definita nel 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 <iostream>
#include <exception>
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:

1. Includi il file header iostream nel nostro programma. Utilizzeremo le sue funzioni senza ottenere errori.
2. Includere il file di intestazione dell'eccezione nel nostro programma. Utilizzeremo le sue funzioni come cosa senza errori.
3. Includi lo spazio dei nomi std nel nostro programma per utilizzare le sue classi senza chiamarlo.
4. Crea una nuova classe denominata newException. Questa classe eredita la classe di eccezione di C++.
5. L'inizio del corpo della classe.
6. Sovrascrivi la funzione membro virtuale what() definita nel file di intestazione dell'eccezione. Descriveremo quindi la nostra eccezione, la nuova eccezione.
7. Inizia la definizione della nuova eccezione.
8. Il messaggio da restituire se viene rilevata la nuova eccezione.
9. Fine della definizione della nuova eccezione.
10. Fine del corpo della classe newException. Il newex è il nome da utilizzare per catturare la nostra nuova eccezione, dopodiché verrà chiamata newException.
11. Chiama la funzione main(). La logica del programma dovrebbe essere aggiunta all'interno del suo corpo. Il { segna l'inizio del suo corpo.
12. Utilizzare un'istruzione try per contrassegnare il codice all'interno del quale dobbiamo contrassegnare l'eccezione. Il segno { segna l'inizio del corpo del blocco try/catch. Il codice circondato da questo verrà protetto.
13. Lancia l'eccezione newex se viene catturata.
14. Fine del corpo della prova.
15. Utilizzare l'istruzione catch per intercettare l'eccezione. Il messaggio di errore dell'eccezione verrà archiviato nella variabile ex.
16. Stampa il messaggio di errore di eccezione sulla console.
17. Fine del corpo dell'istruzione catch.
18. Il programma dovrebbe restituire un valore se viene eseguito correttamente.
19. 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 rilevare un'eccezione, inserisci una sezione di codice sotto il blocco try-catch.
• La parola chiave launch aiuta il programma a generare 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 header delle eccezioni per definire le nostre eccezioni.