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 :
Voici une capture d'écran du code :
Explication du code :
- Incluez le fichier d'en-tête iostream dans le programme pour utiliser son fonctions.
- Incluez le fichier d'en-tête vectoriel dans le programme pour utiliser ses fonctions.
- Incluez l'espace de noms std du programme dans ses classes sans l'appeler.
- Appelez la fonction main(). La logique du programme doit être ajoutée dans son corps.
- Créez un vecteur nommé vec pour stocker des données entières.
- Ajoutez l'élément 0 au vecteur nommé vec.
- Ajoutez l'élément 1 au vecteur nommé vec.
- Un commentaire. Il sera ignoré par le C++ compilateur.
- 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é.
- 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.
- Fin du corps du bloc try/catch.
- Attrapez l'exception. Le message d'erreur renvoyé sera stocké dans la variable ex.
- Imprimez un message sur la console si l'exception est interceptée.
- Extrémité du corps du bloc de capture.
- Le programme doit renvoyer une valeur en cas d'exécution réussie.
- 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 :
Voici une capture d'écran du code :
Explication du code :
- Incluez le fichier d'en-tête iostream dans le programme pour utiliser ses fonctions.
- Incluez l'espace de noms std du programme dans ses classes sans l'appeler.
- Créez une fonction nommée zeroDivision qui prend deux arguments entiers, x et y. La fonction doit renvoyer un résultat double.
- 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.
- Le message à renvoyer/lancer si y est 0.
- Fin du corps de l'instruction if.
- La fonction zeroDivision doit renvoyer la valeur de x/y.
- Fin du corps de la fonction zeroDivision.
- Appelez la méthode main(). Le { marque le début de cette méthode.
- Déclarez une variable entière et attribuez-lui la valeur 11.
- Déclarez une variable entière b et attribuez-lui la valeur 0.
- Déclarez une variable double c et attribuez-lui la valeur 0.
- 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é.
- 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.
- Imprimez la valeur de la variable c sur la console.
- Fin du corps du bloc try/catch.
- Attrapez l'exception. Le message d'erreur renvoyé sera stocké dans le message variable.
- Imprimez le message d'erreur renvoyé sur la console.
- Extrémité du corps du bloc de capture.
- Le programme doit renvoyer une valeur en cas d'exécution réussie.
- 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 :
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 :
Voici une capture d'écran du code :
Explication du code :
- Incluez le fichier d'en-tête iostream dans notre programme. Nous utiliserons ses fonctions sans obtenir d'erreurs.
- Incluez le fichier d'en-tête d'exception dans notre programme. On utilisera ses fonctions comme quoi sans erreurs.
- Incluez l'espace de noms std dans notre programme pour utiliser ses classes sans l'appeler.
- Créez une nouvelle classe nommée newException. Cette classe hérite de la classe d'exception de C++.
- Le début du corps de classe.
- 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.
- Commencez la définition de la nouvelle exception.
- Message à renvoyer si la nouvelle exception est interceptée.
- Fin de la définition de la nouvelle exception.
- 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.
- Appelez la fonction main(). La logique du programme doit être ajoutée dans son corps. Le { marque le début de son corps.
- 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é.
- Lancez l'exception newex si elle est interceptée.
- Fin du corps d'essai.
- Utilisez l'instruction catch pour intercepter l'exception. Le message d'erreur d'exception sera stocké dans la variable ex.
- Imprimez le message d'erreur d'exception sur la console.
- Fin du corps de l'instruction catch.
- Le programme doit renvoyer une valeur s'il s'exécute avec succès.
- 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.