Les erreurs en C++ se classent en deux catégories : les erreurs de compilation (syntaxe, bibliothèque manquante) et les erreurs d'exécution (exceptions), qui surviennent lors de l'exécution et peuvent provoquer un arrêt brutal du programme si elles ne sont pas gérées.
Une exception est un événement anormal survenant à l'exécution (ex. : division par zéro, index hors bornes). En C++, toutes les exceptions dérivent de la classe std::exception. Si elle n'est pas interceptée, le programme se termine anormalement.
Pourquoi utiliser la gestion des exceptions ?
| Avantage | Explication |
|---|---|
| Séparation du code d'erreur | Le code de gestion des erreurs est séparé du flux normal, améliorant la lisibilité |
| Propagation flexible | Une exception peut être interceptée à n'importe quel niveau de la pile d'appels |
| Regroupement par type | Les exceptions peuvent être organisées en hiérarchies de classes |
Gestion des exceptions
La gestion des exceptions C++ repose sur trois mots-clés : try, catch et throw.
try {
// code protégé
if (condition_erreur) throw valeur_exception;
} catch (TypeException e1) {
// traitement de l'exception e1
} catch (TypeException e2) {
// traitement de l'exception e2
} catch (...) {
// attrape tout type d'exception
}| Mot-clé | Rôle |
|---|---|
try | Délimite le bloc de code à surveiller |
throw | Lève une exception ; l'opérande détermine le type levé |
catch | Intercepte une exception d'un type spécifié ; catch(...) attrape tout |
Exemple n°1 — Division par zéro avec throw et catch
#include <iostream>
using namespace std;
double division(int a, int b) {
if (b == 0) throw "Division par zéro!";
return (a / b);
}
int main() {
int a=5, b=0, res;
try {
res = division(a, b);
cout << "résultat = " << res << endl;
} catch (const char* msg) {
cerr << msg << endl;
}
cout << "bye bye";
return 0;
}Division par zéro! bye bye
Si throw lance un const char*, le catch doit capturer un const char*. Un catch(int) ne l'intercepterait pas et le programme se terminerait anormalement.
Exceptions C++ standard
C++ fournit une hiérarchie d'exceptions standard dans <stdexcept> dérivant toutes de std::exception :
| Exception | Description |
|---|---|
std::bad_alloc | Lancée par new en cas d'échec d'allocation |
std::bad_cast | Lancée par dynamic_cast |
std::logic_error | Erreur détectable à la lecture du code |
std::domain_error | Domaine mathématique invalide |
std::invalid_argument | Argument invalide |
std::out_of_range | Accès hors de la plage valide |
std::runtime_error | Erreur détectable uniquement à l'exécution |
std::overflow_error | Débordement arithmétique |
Exceptions définies par l'utilisateur
On peut créer ses propres exceptions en héritant de std::exception et en surchargeant la méthode what().
Exemple — Classe d'exception personnalisée
#include <iostream>
#include <exception>
using namespace std;
class DivisionError : public exception {
public:
const char* what() const throw() {
return "Division par zero!\n";
}
};
double division(int a, int b) {
if (b == 0) throw DivisionError();
return (a / b);
}
int main() {
int a=5, b=0, res;
try {
res = division(a, b);
cout << "résultat = " << res << endl;
} catch (DivisionError& e) {
cerr << e.what() << endl;
}
cout << "bye bye";
return 0;
}Division par zero! bye bye
what()La méthode what(), héritée de std::exception, retourne une description textuelle de l'exception. La surcharger dans vos classes personnalisées est la convention standard en C++.
Discussion (0)
Soyez le premier à laisser un commentaire !
Laisser un commentaire
Votre commentaire sera visible après modération.