Gestion des exceptions C++ :essayez, attrapez, lancez Exemple

Qu'est-ce que la gestion des exceptions en C++ ?

La gestion des exceptions en C++ vous permet de gérer des circonstances inattendues telles que des erreurs d'exécution. Ainsi, chaque fois qu'une circonstance inattendue se produit, le contrôle du programme est transféré à des fonctions spéciales appelées gestionnaires.

Pour intercepter les exceptions, vous placez une section de code sous inspection d'exception. La section de code est placée dans le bloc try-catch.

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.

En l'absence de circonstances exceptionnelles, le code s'exécutera normalement. Les gestionnaires seront ignorés.

Dans ce didacticiel C++, vous apprendrez :

• Qu'est-ce que la gestion des exceptions en C++ ?
• Pourquoi la gestion des exceptions ?
• Mots clés de gestion des exceptions
• Syntaxe :
• Exceptions standards C++
• Exceptions définies par l'utilisateur

Pourquoi la gestion des exceptions ?

Voici la raison de l'utilisation de la gestion des exceptions en 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 qu'elles choisissent. Même si une fonction génère de nombreuses exceptions, elle n'en gérera que certaines. L'appelant gérera les exceptions non interceptées.

Mots clés de gestion des exceptions

La gestion des exceptions en C++ tourne autour de ces trois mots-clés :

• lancer – lorsqu'un programme rencontre un problème, il lève une exception. Le mot-clé throw aide le programme à effectuer le lancer.
• attraper – un programme utilise un gestionnaire d'exceptions pour intercepter une exception. Il est ajouté à la section d'un programme où vous devez gérer le problème. Cela se fait en utilisant le mot-clé catch.
• essayer – 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 lève 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 qui peut 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 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 :

Explication du code :

1. Incluez le fichier d'en-tête iostream dans le programme pour utiliser ses fonctions.
2. Incluez le fichier d'en-tête vectoriel dans le programme pour utiliser ses fonctions.
3. Incluez l'espace de noms std dans le programme à 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 compilateur C++.
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 retourné sera stocké dans la variable ex.
13. Imprimez un message sur la console si l'exception est détectée.
14. Fin du corps du bloc catch.
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 :

Explication du code :

1. Incluez le fichier d'en-tête iostream dans le programme pour utiliser ses fonctions.
2. Incluez l'espace de noms std dans le programme à 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 double résultat.
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 vaut 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éclarer une variable entière et lui attribuer la valeur 11.
11. Déclarer une variable entière b et lui attribuer la valeur 0.
12. Déclarer une variable double c et lui attribuer 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 la variable message.
18. Imprimez le message d'erreur renvoyé sur la console.
19. Fin du corps du bloc catch.
20. Le programme doit renvoyer une valeur en cas d'exécution réussie.
21. Fin du corps de la fonction main().

Exceptions standards C++

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

Exception Description std::exceptionCeci est une exception et la classe parente de toutes les exceptions C++ standard.std::bad_allocCette exception est levée par un nouveau mot-clé.std::bad_castCeci est une exception levée par dynamic_cast.std::bad_exceptionUn dispositif utile pour gérer les exceptions inattendues dans les programmes C++.std::bad_typeidUne exception levée par typeid.std::logic_errorCette exception est théoriquement détectable en lisant code.std::domain_errorCeci est une exception levée après l'utilisation d'un domaine mathématiquement invalide.std::invalid_argumentUne exception levée pour l'utilisation d'arguments invalides .std::length_errorUne exception levée après la création d'un gros std::string.std::out_of_rangeThrown by at method.std::runtime_errorC'est une exception qui ne peut pas être détectée via la lecture du code.std::overflow_errorCette exception est levée après l'occurrence d'un débordement mathématique.std::range_errorCette exception est levée lorsque vous tentez de stocker une valeur hors plage.std::underflow_errorUne exception levée après l'occurrence de m débordement athématique.

Exceptions définies par l'utilisateur

La classe C++ std::exception nous permet de définir des objets pouvant être lancés en tant qu'exceptions. Cette classe a été définie dans l'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 de l'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 :

Explication du code :

1. Inclure le fichier d'en-tête iostream dans notre programme. Nous utiliserons ses fonctions sans obtenir d'erreurs.
2. Inclure le fichier d'en-tête d'exception dans notre programme. Nous utiliserons 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 la classe.
6. Écraser 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. Commencer la définition de la nouvelle exception.
8. Le 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 celui-ci deviendra protégé.
13. Lancer 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().

Résumé :

• Grâce à la gestion des exceptions en C++, vous pouvez gérer les erreurs d'exécution.
• Les erreurs d'exécution sont les erreurs qui se produisent pendant l'exécution du programme.
• La gestion des exceptions vous aide à gérer toutes les circonstances inattendues dans votre programme.
• Lorsque la circonstance inattendue se produit, le contrôle du programme est transféré aux gestionnaires.
• Pour intercepter une exception, vous placez une section de code sous le bloc try-catch.
• Le mot-clé throw aide le programme à lancer des exceptions, aidant ainsi le programme à gérer le problème.
• Le mot clé try permet d'identifier le bloc de code pour lequel certaines exceptions seront activées.
• Nous pouvons écraser la fonction what() du fichier d'en-tête d'exception pour définir nos exceptions.