Gestion des exceptions C ++

Une exception est un problème qui survient lors de l'exécution d'un programme. Une exception C ++ est une réponse à une circonstance exceptionnelle qui survient lors de l'exécution d'un programme, telle qu'une tentative de division par zéro.

Les exceptions fournissent un moyen de transférer le contrôle d'une partie d'un programme à une autre. La gestion des exceptions C ++ repose sur trois mots-clés:try, catch, et throw.

throw- Un programme lève une exception lorsqu'un problème apparaît. Ceci est fait en utilisant unthrow mot-clé.
catch- Un programme intercepte une exception avec un gestionnaire d'exceptions à l'endroit dans un programme où vous souhaitez gérer le problème. lecatch Le mot clé indique la capture d'une exception.
try - Un tryblock identifie un bloc de code pour lequel des exceptions particulières seront activées. Il est suivi d'un ou plusieurs blocs catch.

En supposant qu'un bloc lève une exception, une méthode intercepte une exception en utilisant une combinaison des try et catchmots clés. Un bloc try / catch est placé autour du code qui peut générer une exception. Le code dans un bloc try / catch est appelé code protégé et la syntaxe d'utilisation de try / catch est la suivante:

try {
   // protected code
} catch( ExceptionName e1 ) {
   // catch block
} catch( ExceptionName e2 ) {
   // catch block
} catch( ExceptionName eN ) {
   // catch block
}

Vous pouvez lister plusieurs catch instructions pour attraper différents types d'exceptions au cas où votre try block soulève plus d'une exception dans différentes situations.

Lancer des exceptions

Les exceptions peuvent être lancées n'importe où dans un bloc de code en utilisant throwdéclaration. L'opérande de l'instruction throw détermine un type pour l'exception et peut être n'importe quelle expression et le type du résultat de l'expression détermine le type d'exception levée.

Voici un exemple de levée d'une exception lors de la division par zéro condition -

double division(int a, int b) {
   if( b == 0 ) {
      throw "Division by zero condition!";
   }
   return (a/b);
}

Attraper les exceptions

le catch bloc suivant le tryblock intercepte toute exception. Vous pouvez spécifier le type d'exception que vous souhaitez intercepter et cela est déterminé par la déclaration d'exception qui apparaît entre parenthèses après le mot clé catch.

try {
   // protected code
} catch( ExceptionName e ) {
  // code to handle ExceptionName exception
}

Le code ci-dessus attrapera une exception de ExceptionNametype. Si vous souhaitez spécifier qu'un bloc catch doit gérer tout type d'exception levée dans un bloc try, vous devez mettre une ellipse, ..., entre les parenthèses entourant la déclaration d'exception comme suit -

try {
   // protected code
} catch(...) {
  // code to handle any exception
}

Ce qui suit est un exemple, qui lance une exception de division par zéro et nous l'attrapons dans le bloc catch.

#include <iostream>
using namespace std;

double division(int a, int b) {
   if( b == 0 ) {
      throw "Division by zero condition!";
   }
   return (a/b);
}

int main () {
   int x = 50;
   int y = 0;
   double z = 0;
 
   try {
      z = division(x, y);
      cout << z << endl;
   } catch (const char* msg) {
     cerr << msg << endl;
   }

   return 0;
}

Parce que nous lançons une exception de type const char*, donc tout en interceptant cette exception, nous devons utiliser const char * dans le bloc catch. Si nous compilons et exécutons le code ci-dessus, cela produirait le résultat suivant -

Division by zero condition!

Exceptions standard C ++

C ++ fournit une liste d'exceptions standard définies dans <exception>que nous pouvons utiliser dans nos programmes. Ceux-ci sont organisés dans une hiérarchie de classes parent-enfant illustrée ci-dessous -

Voici la petite description de chaque exception mentionnée dans la hiérarchie ci-dessus -

Sr.Non	Exception et description
1	std::exception Une exception et une classe parente de toutes les exceptions C ++ standard.
2	std::bad_alloc Cela peut être jeté par new.
3	std::bad_cast Cela peut être jeté par dynamic_cast.
4	std::bad_exception C'est un appareil utile pour gérer les exceptions inattendues dans un programme C ++.
5	std::bad_typeid Cela peut être jeté par typeid.
6	std::logic_error Une exception qui peut théoriquement être détectée en lisant le code.
sept	std::domain_error Il s'agit d'une exception levée lorsqu'un domaine mathématiquement invalide est utilisé.
8	std::invalid_argument Ceci est renvoyé en raison d'arguments invalides.
9	std::length_error Ceci est levé quand une trop grosse chaîne std :: string est créée.
dix	std::out_of_range Cela peut être lancé par la méthode 'at', par exemple un opérateur std :: vector et std :: bitset <> :: [] ().
11	std::runtime_error Une exception qui ne peut théoriquement pas être détectée en lisant le code.
12	std::overflow_error Ceci est émis en cas de dépassement mathématique.
13	std::range_error Cela se produit lorsque vous essayez de stocker une valeur hors plage.
14	std::underflow_error Ceci est lancé en cas de dépassement mathématique.

Définir de nouvelles exceptions

Vous pouvez définir vos propres exceptions en héritant et en remplaçant exceptionfonctionnalité de classe. Voici l'exemple, qui montre comment vous pouvez utiliser la classe std :: exception pour implémenter votre propre exception de manière standard -

#include <iostream>
#include <exception>
using namespace std;

struct MyException : public exception {
   const char * what () const throw () {
      return "C++ Exception";
   }
};
 
int main() {
   try {
      throw MyException();
   } catch(MyException& e) {
      std::cout << "MyException caught" << std::endl;
      std::cout << e.what() << std::endl;
   } catch(std::exception& e) {
      //Other errors
   }
}

Cela produirait le résultat suivant -

MyException caught
C++ Exception

Ici, what()est une méthode publique fournie par la classe d'exception et elle a été remplacée par toutes les classes d'exception enfants. Cela renvoie la cause d'une exception.