C++ Gestion des exceptions

Les exceptions sont des problèmes qui surviennent lors de l'exécution d'un programme. Les exceptions en C++ désignent des situations particulières qui se produisent à l'exécution, comme une tentative de division par zéro.

Les exceptions offrent un moyen de transférer le contrôle du programme. La gestion des exceptions en C++ implique trois mots-clés :try、catch、throw。

  • throw:Lorsqu'un problème survient, le programme lève une exception. Cela se fait en utilisantthrowCela est réalisé à l'aide de mots-clés.
  • catch:Là où vous souhaitez gérer le problème, interceptez l'exception à l'aide d'un gestionnaire d'exceptions.catchLe mot-clé est utilisé pour intercepter les exceptions.
  • try: tryLe code dans un bloc identifie l'exception spécifique qui sera déclenchée. Il est généralement suivi d'un ou plusieurs blocs catch.

Si un bloc lance une exception, la méthode utilisée pour intercepter l'exception emploie les mots-cléstryetcatch. Le code qui peut lancer une exception est placé dans un bloc try, et le code à l'intérieur du bloc try est appelé code protégé. La syntaxe d'utilisation d'une instruction try/catch est la suivante :

try { // Code protégé }catch( ExceptionName e1 ) { // bloc catch }catch( ExceptionName e2 ) { // bloc catch }catch( ExceptionName eN ) { // bloc catch }

iftryLes blocs peuvent lancer différentes exceptions dans différents contextes ; dans ce cas, vous pouvez essayer de lister plusieurscatchinstructions, utilisées pour intercepter différents types d'exceptions.

Lancer une exception

Vous pouvez utiliserthrowL'instruction lance une exception n'importe où dans le bloc de code. L'opérande de l'instruction throw peut être n'importe quelle expression, et le type du résultat de l'expression détermine le type de l'exception lancée.

Voici un exemple de lancement d'une exception lors d'une tentative de division par zéro :

double division(int a, int b) { if( b == 0 ) { throw "Condition de division par zéro !"; } return (a/b); }

Intercepter les exceptions

catchle bloc suittryplacé après le bloc, utilisé pour intercepter les exceptions. Vous pouvez spécifier le type d'exception que vous souhaitez intercepter, qui est déterminé par la déclaration d'exception entre parenthèses après le mot-clé catch.

try { // Code protégé }catch( ExceptionName e ) { // Code pour gérer l'exception ExceptionName }

Le code ci-dessus interceptera une exception de typeExceptionNameexception. Si vous voulez qu'un bloc catch gère tout type d'exception levée par un bloc try, vous devez utiliser une ellipse ... à l'intérieur des parenthèses de la déclaration d'exception, comme indiqué ci-dessous :

try { // Code protégé }catch(...) { // Code qui peut gérer n'importe quelle exception }

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

Exemple

#include <iostream> using namespace std; double division(int a, int b) { if( b == 0 ) { throw "Condition de division par zéro !"; } 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; }

Puisque nous avons lancé une exception de typeconst char*exception, donc lors de la capture de cette exception, nous devons utiliser const char* dans le bloc catch. Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

Division by zero condition!

Exceptions standard C++

C++ fournit une série d'exceptions standard, définies dans<exception>que nous pouvons utiliser dans les programmes. Elles sont organisées selon une hiérarchie de classes parent-enfant, comme montré ci-dessous :

C++ 异常的层次结构

Le tableau suivant décrit chaque exception apparaissant dans la hiérarchie ci-dessus :

Exception Description
std::exception Cette exception est la classe parente de toutes les exceptions standard C++.
std::bad_alloc Cette exception peut être lancée parnewThrow.
std::bad_cast Cette exception peut passer à traversdynamic_castThrow.
std::bad_typeid Cette exception peut passer à traverstypeidThrow.
std::bad_exception C'est très utile lors de la gestion des exceptions qui ne peuvent pas être anticipées dans un programme C++.
std::logic_error Exceptions qui peuvent théoriquement être détectées en lisant le code.
std::domain_error Cette exception est levée lorsqu'un domaine mathématique invalide est utilisé.
std::invalid_argument Cette exception est levée lorsqu'un argument invalide est utilisé.
std::length_error Cette exception est levée lorsqu'une std::string trop longue est créée.
std::out_of_range Cette exception peut être levée par des méthodes, telles que std::vector et std::bitset<>::operator[]().
std::runtime_error Exceptions qui ne peuvent théoriquement pas être détectées en lisant le code.
std::overflow_error Cette exception est levée lorsqu'un dépassement de capacité mathématique se produit.
std::range_error Cette exception est levée lorsqu'on tente de stocker une valeur hors limites.
std::underflow_error Cette exception est levée lorsqu'un sous-dépassement mathématique se produit.

Définir de nouvelles exceptions

Vous pouvez définir de nouvelles exceptions en héritant et en surchargeant la classeexception. L'exemple suivant montre comment utiliser la classe std::exception pour implémenter vos propres exceptions :

Exemple

#include <iostream> #include <exception> using namespace std; struct MyException : public exception { const char * what () const throw () { return "Exception C++"; } }; int main() { try { throw MyException(); } catch(MyException& e) { std::cout << "MyException attrapée" << std::endl; std::cout << e.what() << std::endl; } catch(std::exception& e) { // Autres erreurs } }

Cela produira le résultat suivant :

MyException caught
C++ Exception

Ici,what()est une méthode publique fournie par la classe d'exception, qui a été redéfinie par toutes les classes d'exception dérivées. Elle renvoie la cause de l'exception.

autres extensions