1. Les sources d'erreurs
On constate dans le cycle de développement d'un programme que la gestion des erreurs nécessitent parfois plus d'effort de programmation que le fonctionnement normal
2. La gestion d'erreur " à l'ancienne "
Nécessite une suite d'instructions
Exemple : ecrire un texte dans un fichier du disque dur
var MonFichier : TextFile;
ligne : string;
begin
AssignFile(MonFichier, 'Test.txt');
ReWrite(MonFichier);
if IOResult = 0 then
begin
Repeat
ligne := UneFonctionQuiRameneUneString
MonFichier.writeln(ligne)
until igne='' or IOResult <> 0
if IOResult <> 0 then writeln ('problème lors de l''écriture. NO erreur :',IOResult)
CloseFile(MonFichier)
else writeln(problème à l'ouverture du fichier') ;
Le programme deviend rapidement incompréhensible, car le cas général est noyé au milieu de la gestion des erreurs. Le code est alors difficile à maintenir.
Il est impossible de "propager l'erreur" sans variable globale.
3. Les Exceptions
Une exception est une erreur ou unévénement exceptionnel qui interrompt de flux normal d'exécution d'une application.
Lorsque qu'une exception est déclenchée, il y a exécution d'un gestionnaire d'exceptions qui est un moyen structuré pour séparer la logique normale de celle qui gère les erreurs
Cela augmente la lisibilité, la maintenabilité et la robustesse des programmes
En POO, une exception est un objet : il existe une hiérarchie de classes pour particulariser les exceptions
Type EMathError = class(Exception);
Type EInvalidOp = class(EMathError);
Type EZeroDivide = class(EInvalidOp);
Le programmeur peut ainsi créer ses propres exceptions, plus précises, sans affecter le code existant.
Une exception, au travers de ses attributs, peut "transporter" des informations depuis le lieu du déclechement jusqu'au lieu du traitement
4. Gestion des exceptions
Les exceptions sont gérées à l'aide des instructions
Try
(liste d'instrucions)...
Except
on exception1 do instructions...
on exception2 do instructions...
else instructions...
end ;
Exemple
Function Tangente(X : réel)
Begin
try
Tangente := Sin(X)/Cos(X) ;
Except
on EZeroDivide do writeln (x,:mauvais parametre') ;
on EOverflow do writeln (Résultat trop grand') ;
on EMathError do writeln (Erreur de calcul')
else writeln (Erreur inconnue')
end ;
Dans l'exemple, EZeroDivide et EOverFlow héritent de EMathError. Pour leur déclenchement, les placer AVANT ErreurMath, car un seul traitement sera effectué
5. Protection des ressources
Lorsqu'une section de programme réserve une ressource (mémoire, fichier, imprimante, réseau...), il faut s'assurer que la ressource est libérée même si le programme est interrompu par une exception.
La protection des ressources est gérée par les instructions
Essaye
(instructions normales)
DansTousLesCas
(instructions finales)
fin ;
NB : si une exception interrompt la série d'instructions normales, le programme va directement exécuter les instructions finales, puis l'exception est redéclenchée
Exemple
Essaye
TraitementFichier(MonFichier)
DansTousLesCas
MonFichier.Fermer
fin ;
6. Créer ses propres exceptions
Quand on crée une classe, on peut être amené à générer des exceptions spécifiques au comportement des objets de cette classe
Pour déclencher une exception, il faut
Exemple avec TRoue :
déclarer et déclencher l'exception EPneuCrevé
Type EPneuCrevé = class(Exception);
.....
procedure TRoue.rouler ;
var e : EPneuCrevé
debut
si " on roule sur un clou " alors
debut
e:=EpneuCrevé.Create(crevaison due à un clou');
déclencher e ;
fin
fin
....
procedure TVelo.pedaler ;
debut
Essaye .....
Exception
EpneuCrevé faire RéparerRoue()
fin
fin
7 Conclusions
La gestion des erreurs est primordiale dans la robustesse d'une application
La gestion " traditionnelle " avec des si... ou des Case... est compliquée : mélange du traitement normal et de la gestion des erreurs
La POO dispose d'un gestionnaire d'exceptions permettant de séparer le code normal du traitement des erreurs
Les exceptions sont des objets issues de classes avec héritage
Le programmeur peut créer et déclencher ses propres exceptions