C++ Gestion des exceptions : essayer, attraper, lancer un exemple

Si une situation exceptionnelle se produit dans cette section de code, une exception sera levée. Ensuite, le gestionnaire d'exceptions prendra le contrôle du programme.

Si aucune circonstance exceptionnelle ne se produit, le code s’exécutera normalement. Les gestionnaires seront ignorés.

Dans ce nouvel article concernant notre nouveau projet C++ tutoriel, vous apprendrez :

Pourquoi la gestion des exceptions ?

Voici la raison de l'utilisation de la gestion des exceptions dans C++:

• Vous séparerez votre code de gestion des erreurs de votre code normal. Le code sera plus lisible et plus facile à maintenir.
• Les fonctions peuvent gérer les exceptions de leur choix. Même si une fonction génère de nombreuses exceptions, elle n’en gérera que quelques-unes. L'appelant gérera les exceptions non interceptées.

Mots-clés de gestion des exceptions

Gestion des exceptions dans C++ s'articule autour de ces trois mots clés :

• renversement– lorsqu'un programme rencontre un problème, il lève une exception. Le mot-clé throw aide le programme à effectuer le lancement.
• capture– un programme utilise un gestionnaire d'exceptions pour intercepter une exception. Il est ajouté à la section d'un programme dans laquelle vous devez gérer le problème. Cela se fait en utilisant le mot-clé catch.
• Essai– le bloc try identifie le bloc de code pour lequel certaines exceptions seront activées. Il doit être suivi d'un ou plusieurs blocs catch.

Supposons qu'un bloc de code déclenche une exception. L'exception sera interceptée par une méthode utilisant des mots-clés try et catch. Le bloc try/catch doit entourer le code susceptible de lever une exception. Un tel code est appelé code protégé.

Syntaxe

Le try/catch prend cette syntaxe :

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

• Bien que nous ayons une seule instruction try, nous pouvons avoir plusieurs instructions catch.
• ExceptionName est le nom de l'exception à intercepter.
• exception1, exception2 et exceptionN sont vos noms définis pour faire référence aux exceptions.

Exemple 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;
}

Sortie :

Voici une capture d'écran du code :

Code Explication:

1. Incluez le fichier d'en-tête iostream dans le programme pour utiliser son fonctions.
2. Incluez le fichier d'en-tête vectoriel dans le programme pour utiliser ses fonctions.
3. Incluez l'espace de noms std du programme dans ses classes sans l'appeler.
4. Appelez la fonction main(). La logique du programme doit être ajoutée dans son corps.
5. Créez un vecteur nommé vec pour stocker des données entières.
6. Ajoutez l'élément 0 au vecteur nommé vec.
7. Ajoutez l'élément 1 au vecteur nommé vec.
8. Un commentaire. Il sera ignoré par le C++ compilateur.
9. Utilisez l'instruction try pour intercepter une exception. Le { marque le début du corps du bloc try/catch. Le code ajouté dans le corps deviendra le code protégé.
10. Essayez d'accéder à l'élément stocké à l'index 2 (troisième élément) du vecteur nommé vec. Cet élément n'existe pas.
11. Fin du corps du bloc try/catch.
12. Attrapez l'exception. Le message d'erreur renvoyé sera stocké dans la variable ex.
13. Imprimez un message sur la console si l'exception est interceptée.
14. Extrémité du corps du bloc de capture.
15. Le programme doit renvoyer une valeur en cas d'exécution réussie.
16. Fin du corps de la fonction main().

Exemple 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;
}

Sortie :

Voici une capture d'écran du code :

Code Explication:

1. Incluez le fichier d'en-tête iostream dans le programme pour utiliser ses fonctions.
2. Incluez l'espace de noms std du programme dans ses classes sans l'appeler.
3. Créez une fonction nommée zeroDivision qui prend deux arguments entiers, x et y. La fonction doit renvoyer un résultat double.
4. Utilisez une instruction if pour vérifier si la valeur de l'argument variable y est 0. Le { marque le début du corps if.
5. Le message à renvoyer/lancer si y est 0.
6. Fin du corps de l'instruction if.
7. La fonction zeroDivision doit renvoyer la valeur de x/y.
8. Fin du corps de la fonction zeroDivision.
9. Appelez la méthode main(). Le { marque le début de cette méthode.
10. Déclarez une variable entière et attribuez-lui la valeur 11.
11. Déclarez une variable entière b et attribuez-lui la valeur 0.
12. Déclarez une variable double c et attribuez-lui la valeur 0.
13. Utilisez l'instruction try pour intercepter une exception. Le { marque le début du corps du bloc try/catch. Le code ajouté dans le corps deviendra le code protégé.
14. Appelez la fonction zeroDivision et passez aux arguments a et b, c'est-à-dire 11 et 0. Le résultat de cette opération sera stocké dans la variable c.
15. Imprimez la valeur de la variable c sur la console.
16. Fin du corps du bloc try/catch.
17. Attrapez l'exception. Le message d'erreur renvoyé sera stocké dans le message variable.
18. Imprimez le message d'erreur renvoyé sur la console.
19. Extrémité du corps du bloc de capture.
20. Le programme doit renvoyer une valeur en cas d'exécution réussie.
21. Fin du corps de la fonction main().

C++ Exceptions standards

C++ est livré avec une liste d'exceptions standard définies dans classe. Ceux-ci sont décrits ci-dessous :

Exceptions définies par l'utilisateur

Le C++ La classe std::exception nous permet de définir des objets qui peuvent être lancés comme exceptions. Cette classe a été définie dans le en-tête. La classe nous fournit une fonction membre virtuelle nommée quoi.

Cette fonction renvoie une séquence de caractères terminée par un caractère nul de type char *. Nous pouvons l'écraser dans les classes dérivées pour avoir une description d'exception.

Exemple :

#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;	
}

Sortie :

Voici une capture d'écran du code :

Code Explication:

1. Incluez le fichier d'en-tête iostream dans notre programme. Nous utiliserons ses fonctions sans obtenir d'erreurs.
2. Incluez le fichier d'en-tête d'exception dans notre programme. On utilisera ses fonctions comme quoi sans erreurs.
3. Incluez l'espace de noms std dans notre programme pour utiliser ses classes sans l'appeler.
4. Créez une nouvelle classe nommée newException. Cette classe hérite de la classe d'exception de C++.
5. Le début du corps de classe.
6. Remplacez la fonction membre virtuelle what() définie dans le fichier d'en-tête d'exception. Nous décrirons ensuite notre propre exception, la nouvelle exception.
7. Commencez la définition de la nouvelle exception.
8. Message à renvoyer si la nouvelle exception est interceptée.
9. Fin de la définition de la nouvelle exception.
10. Fin du corps de la classe newException. Le newex est le nom à utiliser pour intercepter notre nouvelle exception, après quoi la newException sera appelée.
11. Appelez la fonction main(). La logique du programme doit être ajoutée dans son corps. Le { marque le début de son corps.
12. Utilisez une instruction try pour marquer le code dans lequel nous devons marquer l'exception. Le { marque le début du corps du bloc try/catch. Le code entouré par ceci sera protégé.
13. Lancez l'exception newex si elle est interceptée.
14. Fin du corps d'essai.
15. Utilisez l'instruction catch pour intercepter l'exception. Le message d'erreur d'exception sera stocké dans la variable ex.
16. Imprimez le message d'erreur d'exception sur la console.
17. Fin du corps de l'instruction catch.
18. Le programme doit renvoyer une valeur s'il s'exécute avec succès.
19. Fin du corps de la fonction main().

FAQ