Quelques pratiques pour initier le débat :
- Pensez au couple papier+crayon !
Droggo n'a de cesse de le répéter (depuis le temps, il y a un copyright
) : avant de commencer à coder, couchez votre programme sur papier. Que ce soit en pseudo-code ou en langage courant, écrivez votre programme ou votre algorithme de manière claire et exécutez-le sur papier. Ce n'est qu'après cette étape de conception et de tests que vous pourrez traduire votre programme en Pascal.
- Indentez convenablement votre code
Une bonne indentation facilite la lecture et permet de détecter beaucoup d'erreurs, comme, par exemple, l'absence de fermeture d'un bloc d'instructions.
Qui peut facilement voir où manque un end dans ce code ?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| Program Chiffres_Lettres;
Uses WinCrt;
Var Caractere : Char;
Begin
InitWinCrt;
repeat
Write('Entrez un caractère ("X" pour quitter) : ');
Caractere := ReadKey;
WriteLn;
if Caractere in ['0'..'9'] then
WriteLn('C''est un chiffre.')
else if Caractere in ['A'..'Z','a'..'z'] then begin
Write('C''est une lettre ');
if Caractere in ['A'..'Z'] then
WriteLn('majuscule.') else WriteLn('minuscule.');
else WriteLn('C''est une lettre accentuée ou un caractère spécial.');
WriteLn;
until Caractere = 'X';
DoneWinCrt;
End. |
...alors qu'on le voit tout de suite quand c'est indenté :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
| Program Chiffres_Lettres;
Uses WinCrt;
Var Caractere : Char;
Begin
InitWinCrt;
repeat
Write('Entrez un caractère ("X" pour quitter) : ');
Caractere := ReadKey;
WriteLn;
if Caractere in ['0'..'9']
then
WriteLn('C''est un chiffre.')
else
if Caractere in ['A'..'Z','a'..'z']
then
begin
Write('C''est une lettre ');
if Caractere in ['A'..'Z']
then
WriteLn('majuscule.')
else
WriteLn('minuscule.');
end (* <-- C'est ici ! *)
else
WriteLn('C''est une lettre accentuée ou un caractère spécial.');
WriteLn;
until Caractere = 'X';
DoneWinCrt;
End. |
- Soyez cohérent(e) dans votre approche
Essayez de traiter des problèmes identiques de manière similaire. Combien de fois voit-on qu'un bout de code a été écrit en utilisant un concept puis le bout de code suivant avec une autre approche, alors que la même approche aurait permis d'avoir un code cohérent.
Que ce soit pour vous relire vous-même plus tard ou pour qu'une autre personne lise et comprenne votre code, de grâce ajoutez suffisamment de commentaires là où c'est utile.
Par exemple, dans une procédure, indiquez l'utilité de vos variables locales. Si, dans un traitement, vous effectuez un tri, précédez le tri d'un commentaire du genre "Tri du tableau par quick-sort" : vous serez bien content(e), six mois plus tard, d'avoir ce commentaire pour vous rappeler immédiatement ce que fait votre code sans avoir à le relire pour le comprendre.
- Utilisez des identificateurs parlants
Il est très utile de choisir des noms d'identificateurs qui donnent un maximum de renseignements sur l'utilité d'une variable, un type, une procédure ou fonction, etc.
Par exemple, ce code :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| Const AgeMajorite = 18;
Type TTabEntiers = Array [1..20] of Integer;
Var TableauAges : TTabEntiers;
Function Age_Maximum (Const Tableau : TTabEntiers) : Integer;
Begin
(* ... *)
End;
Begin
(* ... *)
if Age_Maximum(TableauAges) > AgeMajorite
then
(* ... *)
End. |
est beaucoup plus parlant que :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| Type t = Array [1..20] of Integer;
Var a : t;
Function v (const tab : t) : Integer;
Begin
(* ... *)
End;
Begin
(* ... *)
if v(a) > 18
then
(* ... *)
End. |
- Structurez vos programmes
Le Pascal permet énormément de souplesse pour structurer son code. Isolez chaque traitement dans une procédure ou fonction et découpez vos programmes en unités. La structuration logique d'un programme facilite grandement sa compréhension, sa lecture et sa maintenance. De plus, vous pourrez plus aisément aisément réutiliser votre code dans d'autres programmes.
- Une procédure ou fonction est une boîte hermétique
Une procédure ou fonction doit recevoir comme paramètres tout ce dont elle a besoin et ne doit pas travailler directement avec des variables globales. Il faut considérer la procédure ou fonction comme une boîte hermétiquement fermée, qui reçoit d'un côté des paramètres et qui renvoie de l'autre côté un résultat et/ou une version modifiée des paramètres reçus en entrée.
En appliquant systématiquement cette règle, on facilite la compréhension et le débogage d'un programme.
- Transmettez vos paramètres invariables comme constantes
Quand c'est possible (ce qui n'est pas le cas en Turbo Pascal), transmettez à vos procédures et fonctions des paramètres qui ne doivent pas être modifiés comme constantes. Si vous les transmettez par valeur, il sont inutilement recopiés sur la pile, ce qui est un non-sens en matière d'optimisation.
Si l'on reprend un exemple cité plus haut :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| Const AgeMajorite = 18;
Type TTabEntiers = Array [1..20] of Integer;
Var TableauAges : TTabEntiers;
Function Age_Maximum (Const Tableau : TTabEntiers) : Integer;
Begin
(* ... *)
End;
Begin
(* ... *)
if Age_Maximum(TableauAges) > AgeMajorite
then
(* ... *)
End. |
La fonction
Age_Maximum ne modifie pas le tableau
TableauAges, elle ne fait qu'en extraire la valeur maximum. Il est donc logique de passer le tableau comme constante et seule son adresse est déposée sur la pile. Tandis que si on l'avait passé par valeur :
Function Age_Maximum (Tableau : TTabEntiers) : Integer;
il serait intégralement recopié sur la pile, ce qui prendrait inutilement du temps machine et consommerait inutilement de l'espace sur la pile.
- Utilisez des constantes pour représenter des valeurs numériques
En déclarant des constantes pour représenter des valeurs numériques utilisées dans un programme, on se facilite la vie : il suffit de modifier la déclaration d'une constante en tête de programme ou d'unité pour que cela modifie automatiquement tous les exemplaires de sa valeur dans le programme ou l'unité.
6 |
0 |
.