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 pendant l'exécution d'un programme, comme une tentative de division par zéro.

Les exceptions permettent 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 lancer .

• lancer − Un programme lève une exception lorsqu'un problème survient. Cela se fait en utilisant un lancer mot-clé.

• attraper − Un programme attrape une exception avec un gestionnaire d'exceptions à l'endroit du programme où vous voulez traiter le problème. Le hic mot-clé indique la capture d'une exception.

• essayez − Un essai block 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 de try et attraper mots clés. Un bloc try/catch est placé autour du code susceptible de générer une exception. Le code dans un bloc try/catch est appelé code protégé, et la syntaxe pour utiliser 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 répertorier plusieurs prises déclarations pour intercepter différents types d'exceptions au cas où votre essaie block lève plus d'une exception dans différentes situations.

Lancer des exceptions

Les exceptions peuvent être levées n'importe où dans un bloc de code en utilisant throw dé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 lorsque la condition de division par zéro se produit −

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

Récupérer les exceptions

Le hic bloquer après essayer bloc 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 interceptera une exception de ExceptionName taper. Si vous souhaitez spécifier qu'un bloc catch doit gérer tout type d'exception qui est lancée dans un bloc try, vous devez mettre des points de suspension, ..., entre les parenthèses entourant la déclaration d'exception comme suit −

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

Voici un exemple qui lève une exception de division par zéro et nous l'attrapons dans le bloc catch.

Démo en direct

#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 levons une exception de type const char* , donc tout en attrapant 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 standards C++

C++ fournit une liste d'exceptions standard définies dans que nous pouvons utiliser dans nos programmes. Celles-ci sont organisées 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 −

std::exception

Une exception et une classe parente de toutes les exceptions C++ standard.

std::bad_alloc

Cela peut être lancé par nouveau .

std::bad_cast

Cela peut être lancé par dynamic_cast .

std::bad_exception

C'est un dispositif utile pour gérer les exceptions inattendues dans un programme C++.

std::bad_typeid

Cela peut être lancé par typeid .

std ::logic_error

Une exception qui peut théoriquement être détectée en lisant le code.

std::domain_error

Il s'agit d'une exception levée lorsqu'un domaine mathématiquement invalide est utilisé.

std::invalid_argument

Ceci est levé en raison d'arguments non valides.

std::length_error

Ceci est lancé lorsqu'un std::string trop grand est créé.

std ::out_of_range

Cela peut être lancé par la méthode 'at', par exemple un std::vector et std::bitset<>::operator[]().

std::runtime_error

Une exception qui théoriquement ne peut pas être détectée en lisant le code.

std::overflow_error

Ceci est levé si un débordement mathématique se produit.

std::range_error

Cela se produit lorsque vous essayez de stocker une valeur qui est hors plage.

std::underflow_error

Ceci est levé si un sous-dépassement mathématique se produit.

Sr.No	Exception et description
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Définir de nouvelles exceptions

Vous pouvez définir vos propres exceptions en héritant et en remplaçant exception fonctionnalité 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 −

Démo en direct

#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, quoi() 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.