Suivez-nous sur X
|
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z,
ALL
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
A propos d'Obligement
|
|
David Brunet
|
|
|
|
Programmation : Le traitement des erreurs dans un programme
(Article écrit par Thomas Landspurg et extrait d'Amiga News Tech - août 1992)
|
|
Partie importante d'un programme, la gestion des erreurs se révèle souvent difficile à implémenter. On la
relègue à plus tard, et c'est souvent le parent pauvre des programmes. Alors qu'une bonne gestion des erreurs
donne une qualité indéniable au programme.
Mais pourquoi beaucoup de programmes ne gèrent-ils pas très bien les cas d'erreurs ? Tout simplement parce
que la mise en place de ce traitement n'est pas simple. Classiquement, il y a trois grandes méthodes.
La première respecte la programmation structurée. Elle consiste en une série de "IF pas erreur ALORS suite du programme".
En voici un exemple en pseudo-code :
C'est joli en théorie, mais on se retrouve vite avec de nombreuses indentations qui surchargent le code de manière
inutile. En effet, surtout en début de programme, il y a de nombreuses initialisations, demande de ressources, etc.
qui conditionnent la suite des opérations.
Une deuxième méthode, moins jolie, mais souvent utilisée dans le cas de gestion d'erreurs, consiste à utiliser
l'instruction damnée des langages structurés, j'ai nommé GOTO. Exemple :
La troisième méthode, la plus "directe" consiste purement et simplement à utiliser la fonction exit()
(ou return() pour une procédure). Exemple :
Pas terrible, car tout programme structuré se doit d'avoir un seul point d'entrée et un seul point
de sortie par proçédure.
La solution
Il suffit de considérer le traitement des erreurs comme un automate, où chaque étape n'est effectuée
que si la précédente s'est déroulée correctement. Un compteur indique à quelle étape on se trouve,
tandis qu'un drapeau (flag_err) reste à FAUX tant qu'il n'y a pas eu d'erreur. On effectue une
instruction du type "switch() ... case" en fonction du compteur d'étapes. En pseudo-code, cela donne :
La structure du programme est bien respectée, et cela donne un code aisément lisible, surtout dans
les cas où il y a de nombreuses initialisations.
De plus, ce type de programmation utilisant le "switch() ... case" pour effectuer des traitements
séquentiels, peut ne pas être limité au traitement d'erreurs. Il permet justement de rompre une
séquence de manière élégante : à chaque séquence (chaque "case"), il suffit d'indiquer le numéro
de la prochaine séquence à exécuter en modifiant la variable "etape".
Mais j'insiste sur l'importance du traitement d'erreurs, quelle que soit la méthode utilisée, car c'est
ce qui donne un véritable aspect professionnel aux programmes, mais c'est ce qui est le plus dur à réaliser
(j'ai d'ailleurs beaucoup de mal moi-même). Donc, dès le début, pensez aux erreurs !
Le listing qui suit donne un exemple en C de cette méthode. Il s'agit d'un programme qui ne fait rien
d'autre que donner en retour la taille d'un fichier. Cela ne sert pas à grand-chose, sinon à donner
un exemple d'utilisation.
|
