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

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

Gestion des exceptions dans C++ vous offre un moyen 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 détecter les exceptions, vous placez une section de code sous inspection des exceptions. 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.

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.

1 Exemple:

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

Mots-clés de gestion des exceptions

Voici une capture d'écran du code :

Mots-clés de gestion des exceptions

Explication du code :

  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().

2 Exemple:

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

Mots-clés de gestion des exceptions

Voici une capture d'écran du code :

Mots-clés de gestion des exceptions

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 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++ Exceptions standards

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

Exception Description
std :: exception Ceci est une exception et la classe parent de tous les standards C++ des exceptions.
std :: bad_alloc Cette exception est levée par un nouveau mot-clé.
std :: bad_cast Il s'agit d'une exception levée par Dynamic_cast.
std :: mauvaise_exception Un dispositif utile pour gérer les exceptions inattendues dans C++ programmes.
std :: bad_typeid Une exception levée par typeid.
std :: erreur_logique Cette exception est théoriquement détectable par la lecture du code.
std ::domain_error Il s'agit d'une exception levée après l'utilisation d'un domaine mathématiquement invalide.
std :: invalid_argument Une exception levée pour l'utilisation d'arguments non valides.
std :: longueur_erreur Une exception levée après la création d'un gros std::string.
std :: out_of_range Jeté par la méthode.
std :: runtime_error Il s'agit d'une exception qui ne peut pas être détectée via la lecture du code.
std :: overflow_error Cette exception est levée après l'apparition d'un débordement mathématique.
std :: range_error Cette exception est levée lorsque vous tentez de stocker une valeur hors plage.
std :: underflow_error Exception levée après l’apparition d’un débordement mathématique.

Exceptions définies par l'utilisateur

Notre 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.

Mise en situation :

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

Exceptions définies par l'utilisateur

Voici une capture d'écran du code :

Exceptions définies par l'utilisateur

Explication du code :

  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().

Résumé

  • Avec gestion des exceptions dans C++, vous pouvez gérer les erreurs d'exécution.
  • Les erreurs d'exécution sont les erreurs qui se produisent lors de l'exécution du programme.
  • La gestion des exceptions vous aide à gérer toute circonstance inattendue dans votre programme.
  • Lorsqu'une 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 à lever 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.