Gestion des exceptions C ++: exemple Try, Catch, throw

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é vers 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.

Dans le cas où aucune circonstance exceptionnelle ne se produit, 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 standard 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 de leur choix. Même si une fonction lève 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 ++ s'articule autour de ces trois mots-clés:

throw - lorsqu'un programme rencontre un problème, il lève une exception. Le mot-clé throw aide le programme à effectuer le lancer.
catch - 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. C'est fait en utilisant le mot-clé catch.
try - le bloc try identifie le bloc de code pour lequel certaines exceptions seront activées. Il doit être suivi d'un / 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 and catch. Le bloc try / catch doit entourer le code qui peut lever une exception. Un tel code est connu sous le nom de 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.
Les exceptions1, exception2 et exceptionN sont vos noms définis pour faire référence aux exceptions.

Exemple 1:

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

Production:

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 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 compilateur C ++.
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.
Fin du corps du bloc de capture.
Le programme doit renvoyer une valeur lors de l'exécution réussie.
Fin du corps de la fonction main ().

Exemple 2:

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

Production:

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 double résultat.
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 égal à 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 affectez-lui la valeur 0.
Déclarez une variable double c et affectez-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.
Fin du corps du bloc de capture.
Le programme doit renvoyer une valeur lors de l'exécution réussie.
Fin du corps de la fonction main ().

Exceptions standard 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 :: exception	Il s'agit d'une exception et de la classe parente de toutes les exceptions C ++ standard.
std :: bad_alloc	Cette exception est levée par un nouveau mot-clé.
std :: bad_cast	Il s'agit d'une exception lancée par dynamic_cast.
std :: bad_exception	Un périphérique utile pour gérer les exceptions inattendues dans les programmes C ++.
std :: bad_typeid	Une exception levée par typeid.
std :: erreur_logique	Cette exception est théoriquement détectable par la lecture de code.
std :: domain_error	Il s'agit d'une exception lancé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 :: length_error	Une exception levée après la création d'un gros std :: string.
std :: out_of_range	Jeté par une 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'occurrence d'un débordement mathématique.
std :: range_error	Cette exception est levée lorsque vous essayez de stocker une valeur hors plage.
std :: underflow_error	Une exception levée après l'occurrence d'un dépassement insuffisant mathématique.

Exceptions définies par l'utilisateur

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

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

Exemple:

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

Production:

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. Nous utiliserons 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.
Démarrez la définition de la nouvelle exception.
Le 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 cela deviendra 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 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 de 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 à lever des exceptions, aidant 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.