Mécanisme de gestion des exceptions C++ et exemples de code

Mécanisme de gestion des exceptions C++ et exemples de code

Dans la programmation C++, le mécanisme de gestion des exceptions est un concept très important, qui peut nous aider à gérer les erreurs d'exécution et les situations inattendues, rendant le programme plus robuste et fiable. Cet article présentera le mécanisme de gestion des exceptions en C++, y compris la définition des exceptions, le lancement d'exceptions, la capture d'exceptions, les gestionnaires d'exceptions, etc., et fournira quelques exemples de code pour aider les lecteurs à mieux comprendre et appliquer.

1. Définition de l'exception

Lors de l'exécution normale du programme, si des erreurs non gérées ou des situations inattendues sont rencontrées, une exception se produira. Les exceptions peuvent être comprises comme un mécanisme de protection du programme, qui peut fournir des informations sur les erreurs et quitter le programme en douceur lorsqu'une erreur se produit dans le programme afin de garantir la sécurité et la fiabilité du programme.

C++ définit certaines classes d'exceptions standard, qui représentent différents types d'exceptions, telles que : std::exception, std::bad_alloc, std::runtime_error, etc. Nous pouvons également personnaliser les classes d'exception pour représenter des situations d'exception spécifiques.

2. Lancer une exception

Lorsqu'une exception se produit dans le programme, vous pouvez utiliser le mot-clé throw pour lever l'exception et transmettre l'objet d'exception au gestionnaire d'exception. Habituellement, la syntaxe pour lever une exception est la suivante :

throw exceptionType(argument);

Parmi eux, exceptionType est le type de la classe d'exception et l'argument est le paramètre de l'objet d'exception, qui peut être n'importe quel type de données.

Ce qui suit est un exemple de code simple qui montre comment lancer une classe d'exception standard std::runtime_error et transmettre un message d'erreur en paramètre :

#include <iostream>
#include <stdexcept>

void division(int a, int b){
  if (b == 0){
    throw std::runtime_error("Division by zero");
  }
  std::cout << "Result: " << a/b << std::endl;
}

int main(){
  try{
    division(10, 0);
  }
  catch(std::exception& e){
    std::cout << "Exception caught: " << e.what() << std::endl;
  }
  return 0;
}

Dans le code ci-dessus, lorsque le diviseur est 0, le programme lancera un std ::runtime_errorException et transmettez une chaîne de message d'erreur en paramètre. Dans la fonction principale, nous utilisons l'instruction try-catch pour intercepter cette exception et imprimer le message d'erreur d'exception.

3. Attraper les exceptions

Lorsque le programme lève une exception, nous devons intercepter et gérer l'exception pour éviter le crash du programme. Les exceptions peuvent être interceptées à l'aide d'instructions try-catch, la syntaxe est la suivante :

try{
  // 可能抛出异常的代码
}
catch(exceptionType1& e1){
  // 处理类型为exceptionType1的异常
}
catch(exceptionType2& e2){
  // 处理类型为exceptionType2的异常
}
catch(...){
  // 处理所有类型的异常
}

Dans le bloc d'instructions try, nous pouvons inclure du code qui peut générer des exceptions. Lorsque le programme lève une exception, il sort du bloc d'instruction try et entre dans le bloc d'instruction catch correspondant pour un traitement basé sur la correspondance du type d'exception et de l'instruction catch. La dernière instruction catch, catch(...), peut gérer tous les types d'exceptions, mais son utilisation n'est pas recommandée car elle perdrait des informations sur l'objet d'exception et n'est pas pratique pour le débogage et la maintenance du programme.

Ce qui suit est un exemple de code simple qui montre comment intercepter une exception std::runtime_error et la gérer :

#include <iostream>
#include <stdexcept>

void division(int a, int b){
  if (b == 0){
    throw std::runtime_error("Division by zero");
  }
  std::cout << "Result: " << a/b << std::endl;
}

int main(){
  try{
    division(10, 0);
  }
  catch(std::runtime_error& e){
    std::cout << "Exception caught: " << e.what() << std::endl;
  }
  return 0;
}

Dans le code ci-dessus, lorsque le diviseur est 0, le programme lève une exception std::runtime_error. Dans la fonction principale, nous utilisons l'instruction try-catch pour intercepter cette exception et imprimer le message d'erreur d'exception.

4. Gestionnaire d'exceptions

En plus de l'instruction try-catch, C++ fournit également un mécanisme spécial pour gérer les exceptions non interceptées, appelé gestionnaire d'exceptions. Vous pouvez utiliser la fonction std::set_terminate() pour enregistrer un gestionnaire d'exceptions et exécuter le code du gestionnaire lorsqu'une exception non interceptée se produit dans le programme. Les gestionnaires d'exceptions sont généralement utilisés pour gérer des erreurs graves, telles qu'une mémoire insuffisante, des erreurs de lecture et d'écriture de fichiers, etc.

Ce qui suit est un exemple de code simple qui montre comment enregistrer et utiliser un gestionnaire d'exceptions :

#include <iostream>
#include <cstdlib>

void myExceptionHandler(){
  std::cout << "Unhandled exception" << std::endl;
  std::exit(1);
}

int main(){
  std::set_terminate(myExceptionHandler);
  int* p = new int[1000000000];
  delete[] p;
  return 0;
}

Dans le code ci-dessus, nous utilisons la fonction std::set_terminate() pour enregistrer un gestionnaire d'exceptions myExceptionHandler, et dans la fonction principale Allouez un grand bloc de mémoire. En raison d'une mémoire insuffisante, le programme lancera une exception std::bad_alloc. Cette exception sera interceptée par le processeur myExceptionHandler, imprimera un message d'erreur et quittera le programme.

Résumé

Le mécanisme de gestion des exceptions C++ est une partie très importante du programme. Il peut nous aider à gérer les erreurs d'exécution et les situations inattendues, rendant le programme plus robuste et fiable. Cet article présente les définitions d'exceptions, le lancement d'exceptions, la capture d'exceptions, les gestionnaires d'exceptions, etc. en C++, et fournit quelques exemples de code pour aider les lecteurs à mieux les comprendre et les appliquer. Dans la programmation réelle, nous devons utiliser le mécanisme de gestion des exceptions de manière raisonnable et éviter les abus et les utilisations abusives pour garantir l'efficacité et la maintenabilité du programme.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!