Discussion :

[Transgarp]

NB. Ce fil de discussion fait suite au sujet :
http://www.developpez.net/forums/sho...d.php?t=504428

Souvent je place des documents texte après le End. comme aide mémoire du fonctionnement du programme.

[krachik]

Bonjour

Souvent je place des documents texte après le End. comme aide mémoire du fonctionnement du programme.

De bons commentaires dans le programme et non à la fin suffiraient amplement pour comprendre le fonctionnement de celui-ci.
Et même en plus des commentaires , le "document texte" dont tu parles je crois doit etre pour resumer de façon globale ce que va faire le programme ,il faudrait plutot le mettre au debut du programme comme ça d'entrée on sait ce à quoi on a faire .
@+

[Transgarp]

Bah, souvent le nom que je donne à la procédure ou la fonction explique l'opération à effectuer.

Petit exemple de ma facon de programmer.

J'arrive à me retrouver dans des cas de code que j'ai programmé il y a 20 ans.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
 
Program GPG;
 
{$F+}
 
Uses
{$IFDEF DPMI}
  Crt,Dos,Printer,CHR_UNIT,
  GPG_BASE,GPG_BOOK,GPG_DATA,GPG_FICH,GPG_GED,GPG_RECH,GPG_ROOT,GPG_SORT,
  GPG_TYPE,GPG_TREE,GRP_CONS,GRP_FONC,GRP_GRAP,GRP_PROC,GRP_TYPE;
{$ELSE}
  Crt,Dos,Overlay,Printer,CHR_UNIT,
  GPG_BASE,GPG_BOOK,GPG_DATA,GPG_FICH,GPG_GED,GPG_RECH,GPG_ROOT,GPG_SORT,
  GPG_TYPE,GPG_TREE,GRP_CONS,GRP_FONC,GRP_GRAP,GRP_PROC,GRP_TYPE;
{$ENDIF}
 
{$O CHR_UNIT}
{$O GPG_8514}
{$O GPG_BASE}
{$O GPG_BOOK}
{$O GPG_DATA}
{$O GPG_FICH}
{$O GPG_PROC}
{$O GPG_RECH}
{$O GPG_ROOT}
{$O GPG_SORT}
{$O GPG_TREE}
 
Var
  FE,GG,I,IK,J,JK,PT,WD,WE  : Byte;
  IO                        : Word;
  WPP                     : PtrL1592at;
  ZZZ                      : PtrS04780at;
 
Begin
  WD:=FileExist('D:\GRP\DAT\GPG\DAT.GPG');
  WE:=FileExist('D:\GRP\DAT\GPG\ERR.GPG');
  FE:=FileExist('D:\GRP\DAT\GPG\WINBAT');
 
{$IFDEF DPMI}
{$ELSE}
  OvrInit('D:\TMP\GPG.OVR');
  If OvrResult<>OvrOk then OvrInit('D:\GRP\OVR\GPG.OVR');
  If OvrResult<>OvrOk then WriteErrorOVR;
{$ENDIF}
 
  Test_Print(FE, PT,IO); GetMem(WPP,MemTPX(5580)); GetMem(ZZZ,MemTPX(2835));
  For J:=0 to 4 Do For I:=1 to 7 Do ZZZ^[J,I]:=Strings(80,' ');
  For J:=1 to 15 Do For I:=0 to 91 Do WPP^[J,I]:=0;
  Repeat
    SetTextMode(3); Color(0,7); ClrScr; WriteOwner(13,4); Color(10,0); GotoXY(9,2);
    If FE=0
    then Write('      Mode DOS         ')
    else Write('      Mode Windows     ');
    WriteXY(9,06,C1s); WriteXY(9,07,'³      GENEALOGIE     ³');
    WriteXY(9,08,C2s); WriteXY(9,09,'³    Version  2.00    ³');
    WriteXY(9,10,C3s); Color(14,0); WriteXY(9,12,'Pèse ESC pour System   ');
    If WD=1 then Color(12,0);
    WriteXY(9,WhereY+1,'Pèse  A  pour Arbre    ');
    If WD=0 then WriteXY(9,WhereY+1,'Pèse  B  pour Base     ');
    Color(14,0); WriteXY(9,WhereY+1,'Pèse  C  pour Caractère');
    If WE=0 then WriteXY(9,WhereY+1,'Pèse  D  pour Data     ');
    WriteXY(9,WhereY+1,'Pèse  F  pour Fichier  ');
    If WD=0 then WriteXY(9,WhereY+1,'Pèse  G  pour Gedcom   ');
    If WD=0 then
    Begin
      If IO>0 then Color(12,0);
      WriteXY(9,WhereY+1,'Pèse  L  pour Livre    ');
    End;
    If WD=1 then Color(12,0) else Color(14,0);
    WriteXY(9,WhereY+1,'Pèse  O  pour Origine  ');
    WriteXY(9,WhereY+1,'Pèse  R  pour Recherche'); Color(14,0);
    IF FE=0
    then WriteXY(9,WhereY+1,'Pèse  M  pour Mode WIN ')
    else WriteXY(9,WhereY+1,'Pèse  M  pour Mode DOS ');
    If WD=1 then WriteXY(9,WhereY+1,'Pèse  S  pour Sort     ');
    WriteXY(9,25,'MEM='); Write(MemAvail:9,' DF=',DiskFree(0) Div 150:6);
    Cursor(0,7);
    Repeat
      InkeyJ(IK,JK); GG:=0;
      Case IK of
         27,46 : GG:=1;
         65    : GG:=2;
         66    : If WD=0 then GG:=3;
         67    : GG:=4;
         68    : If WE=0 then GG:=5;
         70    : GG:=6;
         71    : If WD=0 then GG:=7;
         76    : If WD=0 then GG:=8;
         77    : GG:=12;
         79    : GG:=9;
         82    : GG:=10;
         83    : GG:=11;
        255    : GG:=255;
      End;
    Until GG>0;
 
 
    Case GG of
       2 : P_Arbre(IO,PT,WD);
                   {          03             11 12 13 14    44 79 90 91    }
       3 : P_Base(WD);
                   {          03             11 12 13 14    44 79 90 91    }
       4 : P_Chr(1);
       5 : P_Data(IO, WD,WPP,ZZZ);
                   { 00 01 02 03 04 05    10 11 12 13 14 33 44 79 90 91    }
       6 : P_Fichier(IO,PT);
                   { 00 01 02 03 04 05 06 10 11 12 13 14 33 44 79 90 91 95 }
       7 : P_Gedcom;
       8 : P_Book(IO,PT);
                   { 00 01    03 04 05 06    11 12 13 14       79 90 91    }
       9 : P_Origine(IO,PT);
                   {          03             11 12 13 14    44 79 90 91    }
      10 : P_Rech(IO,PT);
                   {          03             11 12 13 14    44 79 90 91 95 }
      11 : Fichier_Sort(WD);
      12 : Begin
             FE:=1-FE; Ecrire_Fichier_Signal(FE,'D:\GRP\DAT\GPG\WINBAT');
             Test_Print(FE, PT,IO);
           End;
    End;
  Until GG=1;
  FreeMem(ZZZ,MemTPX(2835)); FreeMem(WPP,MemTPX(5580)); Color(15,0); SetTextMode(3);
  If PT in [1,2] then Prt(5,48,0,160,48);
End.
 
 GPG_RECH.DOC   (Font Num = 1004; Line = 80; Orient = P)
 GPG_ROOT.DOC   (Font Num = 1004; Line = 80; Orient = P)
 GPG_TREE.DOC   (Font Num = 1001; Line = 65; Orient = L)

[diden138]

alors disons que tu est un pro du désordre .
tu t y trouve ok mais il faut penser aussi aux gens qui pourrait utiliser notre code
cordialement @+

[droggo]

Cei,

J'ose espérer que ce n'est pas un prof qui t'a appris à écrire du code comme ça.

Si tu reviens à la programmation après une période d'arrêt, fais un effort sur la présentation du code. Tu verras que ça te sera utile, même si "J'arrive à me retrouver dans des cas de code que j'ai programmé il y a 20 ans.", ne serait-ce que pour le faire lire par d'autres, comme rappelé par diden138.

Une présentation "propre" implique plus ou moins :

- des noms (procédures, fonctions, types, constantes, variables...) ayant un rapport avec leur rôle (par exemple, ne pas appeler "soupiere" une variable contenant les données concernant un couteau ))).

- du code indenté régulièrement et de manière cohérente

- du code aéré, c'est à dire des lignes vides pour séparer les différents blocs fonctionnels d'une fonction, et, bien entendu, pour séparer les différentes procédures/fonctions (à ce niveau là, je préconise même d'ajouter une ligne commentée, genre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
procedure blabla
...
end;
 
{ ---------------------------------------------------------- }
 
function allo : boolean;
...
end;

- et enfin, des commentaires clairs et précis, suffisamment, mais pas trop (pas la peine de mettre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
    {lecture du prix }
    readln(prix);

on voit ici un des intérêts des noms bien utilisés : le code devient auto-commenté).
Généralement, on met, au minimum

* au début du programme, ce qu'il est chargé de faire (pour une unité, le but global des procedures/fonctions... définies, par exemple "Implémentation de calcul multi-précision").

* à quoi correspondent les types, constantes définis, si nécessaire
( pas la peine de mettre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
const
  lim = 1000;
 
type
  ma_Table = array [1..lim] of Integer; { tableau de 1000 éléments entiers }

surtout que là on mélange une valeur en dur avec la définition d'une constante, bonjour la maintenance)

* un petit commentaire pour expliquer ce que fait une procédure/fonction, idem pour les différents blocs fonctionnels, si ce n'est pas immédiatement apparent

* ne pas hésiter à développer l'algorithme utilisé s'il sort des grands classiques que tous devraient connaître (même dans ce cas, il n'est pas inutile de rappeler "blabla ..... par algorithme trucmuche), au moins les étapes délicates, s'il y en a.

Bref, tout doit être fait pour que le code soit clair et facilement lisible/compréhensible, c'est nécessaire pour la maintenance, point primordial trop souvent oublié.

[Transgarp]

J'ai fait un BAC en informatique de génie à l'Université Laval entre 1990-1994

Un programme que j'avais à remettre dans le cours d'Infographie IFT10558 à l'automne 1992

J'ai eu 95% comme résultat de ce programme

Excusez, pour les caractères spéciaux du style éèêâà, ils vont vous paraître tout bizarre car je n'ai pas le temps de réécrire le programme en mode texte. Il vient directement du code BP7 et j'ai fait attention pour ce travail de bien aérer les lignes de code, ce que je fais moins en pratique pour mes applications personnelles et question d'un visuel plus rapide.

Vous verrez que je suis aussi capable de documenter pleinement un programme, mais que dans des big programmes avec plusieurs overlay, 50000 lignes de codes, le moindre caractère de documentation diminue l'espace mémoire pour compiler ce dit programme.

Pour plus de facilité de lecture j'écris plusieurs commandes sur la même ligne pour avoir un visuel plus rapide.

Sur une demie douzaine de mes programmes que j'utilise à tous les jours, la moindre ligne de code inutile, de terme trop long ou trop documentée, diminue le nombre de variable à utiliser.

Autre chose, l'informatique n'est pas mon travail, je programme par plaisir à la maison et mon boulot est la mécanique moto

Alors le fait que les gens puissent comprendre ou non mes programmes m'importe peu, l'important est qu'après 10 ans, je peu relire mes programmes comme si je les avait écris la veille et c'est ce qui se passe.

A part l'Université, je n'ai jamais fait de programmes pour les autres ou dans quelques cas rare ou des gens en Maitrise Informatique en arrachait avec du code vu qu'ils étaient plus spécialisé organigramme sur tableau que faire du code.

Ma facon de nommer les fonctions et procédures est pareille pour tout mes programmes et en plus j'utilise en commun des groupes de fonctions et de procédures pour une trentaine de programmes.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
 
Program TP6;                           { Tours de Hanoi                       }
 
{ Ce programme a ‚t‚ r‚alis‚ dans le mode texte et montre une application     }
{ du principe de la r‚cursivit‚ utilis‚ en informatique.                      }
{                                                                             }
{ Au d‚part 4 questions sont demand‚es … l'utilisateur:                       }
{                  - Le nombre d'anneaux.                                     }
{                  - La tour source.                                          }
{                  - La tour cible.                                           }
{                  - La vitesse de d‚placement de l'anneau.                   }
{                                                                             }
{ Au d‚but, la vitesse, le temps de d‚part et les anneaux sont affich‚s       }
{                                                                             }
{ A la fin, le temps d'arriv‚e, le nombre de mouvement ex‚cut‚ et             }
{ la nouvelle position des anneaux sont affich‚s, et un menu demande          }
{ la prochaine op‚ration … ex‚cuter:                                          }
{                  - PŠse ESC pour Sortir                                     }
{                  - PŠse TAB pour Continuer                                  }
 
Uses
  Crt, Dos;
Const
  BASE          =    20;               { Plancher des 3 Tours                 }
  LIGNE_BASSE   =    24;               { Ligne du bas de l'‚cran              }
  NB_ANNEAU_MAX =    12;               { Nombre maximum d'anneau              }
  TOUR_POSI                            { Position en X des 3 Tours            }
  : Array[1..3] of Integer = (2, 28, 54);
 
Type
  Matrice_A     = Array[0..NB_ANNEAU_MAX + 1] of Integer;
  Matrice_B     = Array[1..NB_ANNEAU_MAX, 0..1] of Integer;
  Matrice_C     = Array[1..3] of Integer;
  Matrice_S     = Array[1..NB_ANNEAU_MAX + 1] of String[NB_ANNEAU_MAX * 2 + 1];
 
Var
  IK               : Char;             { Cl‚ lu du clavier                    }
  A, B,                                { Compteurs divers                     }
  HAUT,                                { Plafond des tours                    }
  NB_MOUVEMENT,                        { Indicateur du nombre de mouvement    }
  NIVEAU_RECURSION,                    { Niveau de r‚cursivit‚ de proc‚dure   }
  TEMPS_X,                             { Temps de d‚placement en X            }
  TEMPS_Y,                             { Temps de d‚placement en Y            }
  VITESSE          : Integer;          { Vitesse de d‚placement des anneaux   }
  ANNEAU           : Matrice_S;        { Dessin des anneaux                   }
  ANNEAU_NUM,                          { Num‚ro des anneaux                   }
  TOUR_SOURCE,                         { Tour Source                          }
  TOUR_CIBLE       : Matrice_A;        { Tour Cible                           }
  ANNEAU_POSI      : Matrice_B;        { Position des anneaux                 }
  TOUR_HAUTEUR     : Matrice_C;        { Hauteur des Tours                    }
 
{ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿}
{³                                Fonction TP2                               ³}
{ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ}
{-----------------------------------------------------------------------------}
Function StrNombre(NOMBRE : Integer) : String;
{ Transformation d'un nombre entier en une chaine de 2 caractŠres.            }
{ Analogie de la proc‚dure Str interdite                                      }
Var
  A, B   : Byte;
  CHAINE : String;
Begin
  B      := 10;
  CHAINE := '';
  For A := 1 to 2 Do
  Begin
    CHAINE := CHAINE + Chr(NOMBRE Div B + 48);
    NOMBRE := NOMBRE Mod B;
    B      := B Div 10;
  End;
  StrNombre := CHAINE;
End;
 
{-----------------------------------------------------------------------------}
Function ValChaine(CHAINE_1 : String) : Integer;
{ Transformation d'une chaine de 4 caractŠres en nombre entier.               }
{ Analogie de la proc‚dure Val interdite                                      }
Var
  A                       : Byte;      { Compteur                             }
  MULTIPLICATEUR, NOMBRE  : Integer;
Begin
  NOMBRE         := 0;
  MULTIPLICATEUR := 1000;
  For A := 1 to 4 Do
  Begin
    NOMBRE         := NOMBRE + (Ord(CHAINE_1[A]) - 48) * MULTIPLICATEUR;
    MULTIPLICATEUR := MULTIPLICATEUR Div 10;
  End;
  ValChaine := NOMBRE;
End;
 
{ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿}
{³                               Proc‚dure TP2                               ³}
{ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ}
{-----------------------------------------------------------------------------}
Procedure Valider_Entier(Var NOMBRE  : Integer;  { Coordonn‚e format entier   }
                             MINIMUM,            { Nombre limite min permis   }
                             MAXIMUM : Integer); { Nombre limite max permis   }
Const
  CHIFFRE : Set of '0'..'9' = ['0','1','2','3','4','5','6','7','8','9'];
Var
  EFFACE, A, LONGEUR : Byte;           { Efface, Compteur, longueur CHAINE_1  }
  INKEY              : Char;           { CaractŠre lu du clavier              }
  CHAINE_1, CHAINE_2 : String;         { Sert pour r‚ajustement de CHAINE_1   }
Begin
  EFFACE := 1;
  While (EFFACE = 1) or (LONGEUR > 4) Do
  Begin
    INKEY    := #1;
    LONGEUR  := 0;
    CHAINE_1 := '';
    While (INKEY <> #13) and (LONGEUR < 5) Do
    Begin                    { Lecture du clavier                             }
      Write(' ',#8);
      INKEY := ReadKey;      { ReadKey indispensable pour l'invisibilit‚      }
      If (INKEY = #8) and (LONGEUR > 0)
      then Begin             { Effacement du dernier caractŠre de la CHAINE_1 }
             LONGEUR := LONGEUR - 1;
             Write(#8,' ',#8);
             CHAINE_2 := '';
             For A := 1 to LONGEUR Do CHAINE_2 := CHAINE_2 + CHAINE_1[A];
             CHAINE_1 := CHAINE_2;
           End
      else If CHIFFRE * [INKEY] <> [] then
           Begin             { Ajout d'un nouveau caractŠre … la CHAINE_1     }
             LONGEUR := LONGEUR + 1;
             CHAINE_1 := CHAINE_1 + INKEY;
             Write(INKEY);
           End;
    End;
    If CHAINE_1 = '' then Write('0');
                             { Si Enter sans caractŠre, NOMBRE sera 0         }
    If LONGEUR > 4
    then EFFACE := 1         { Message pour effacer CHAINE_1                  }
    else Begin               { Ajustement … 4 caractŠres de CHAINE_1          }
           For A := 1 to 4 - LONGEUR Do CHAINE_1 := '0' + CHAINE_1;
           If (ValChaine(CHAINE_1) > MAXIMUM)
           or (ValChaine(CHAINE_1) < MINIMUM)
           then EFFACE := 1            { Message pour effacer CHAINE_1        }
           else EFFACE := 0;           { Message pour valider CHAINE_1        }
         End;
    If EFFACE = 1 then                 { Efface CHAINE_1                      }
    For A := 1 to LONGEUR Do Write(#8,' ',#8);
  End;
  NOMBRE := ValChaine(CHAINE_1);       { Conversion num‚rique de CHAINE_1     }
End;
 
{ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿}
{³                               Proc‚dure TP6                               ³}
{ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ}
{-----------------------------------------------------------------------------}
Procedure Afficher_Temps(LY : Byte; CHAINE : String);
{ GetTime mˆme si interdit est la seule facon de mesurer le temps sur PC      }
Var
  HEURE, MINUTE, SECONDE, SEC100 : Word;
Begin
  GetTime(HEURE, MINUTE, SECONDE, SEC100);
  GotoXY(1, LY);
  Write(CHAINE);
  If HEURE < 10 then Write('0', HEURE) else Write(HEURE:2);
  If MINUTE < 10 then Write(':0', MINUTE) else Write(':', MINUTE:2);
  If SECONDE < 10 then Write(':0', SECONDE) else Write(':', SECONDE:2);
End;
 
{-----------------------------------------------------------------------------}
Procedure Color(A, B : Byte);          { Analogie de Color(a,b) de BASIC      }
Begin
  Textcolor(A);
  TextBackground(B);
End;
 
{-----------------------------------------------------------------------------}
Procedure Cursor(A, B : Byte);         { Efface le curseur aprŠs affichage    }
Begin
  Color(B, B);
  Write(' ', #8);
  Color(A, B);
End;
 
{-----------------------------------------------------------------------------}
Procedure Initialiser; { Initialise l'‚cran et obtient le nombre d'anneau     }
Begin
  Color(15, 1);                         { Initialise la couleur de l'‚cran     }
  ClrScr;
  Color(12, 1);
  GotoXY(30, 1);
  Write('TOURS de HANOI');             { Affiche le nom du programme          }
  Cursor(14, 1);
  GotoXY(1, 24);
  Write('Nombre d', #39, 'Anneau (1 … ', StrNombre(NB_ANNEAU_MAX), ') ');
  Cursor(14, 1);
  GotoXY(26, 24);
  Valider_Entier(ANNEAU_NUM[1], 0, NB_ANNEAU_MAX);
  GotoXY(1, 24);
  Write(' ':79);                       { Nettoie la ligne de commande         }
  GotoXY(1, 24);
  Write('Entrer le num‚ro de la tour source (1 … 3) ');
  Valider_Entier(TOUR_SOURCE[0], 1, 3);
  GotoXY(1, 24);
  Write(' ':79);
  GotoXY(1, 24);
  Write('Entrer le num‚ro de la tour cible (1 … 3) ');
  Valider_Entier(TOUR_CIBLE[0], 1, 3);
  GotoXY(1, 24);
  Write(' ':79);
  GotoXY(1, 24);
  Write('Entrer la vitesse de d‚placement ( 1=>10000æsec  …  4=>1 æsec) ');
  Valider_Entier(VITESSE, 1, 4);
  GotoXY(1, 24);
  Write(' ':79);
  Color(15, 1);
  For A := 1 to VITESSE Do
  Begin TEMPS_X:=TEMPS_X Div 10; TEMPS_Y:=TEMPS_Y Div 10; End;
 
  For A := 1 to ANNEAU_NUM[1] Do
  Begin                                { Cr‚ation des anneaux                 }
    ANNEAU[A] :='';
    For B := 1 to NB_ANNEAU_MAX * 2 + 1 Do ANNEAU[A] := ANNEAU[A] + ' ';
    For B := NB_ANNEAU_MAX + 1 - A to NB_ANNEAU_MAX + A + 1 Do
      ANNEAU[A, B] := #219;
  End;
 
  HAUT := BASE - ANNEAU_NUM[1];
  For A := HAUT to HAUT + ANNEAU_NUM[1] Do for B := 0 to 2 Do
  Begin                                { Cr‚ation des tours                   }
    GotoXY(B * 26 + 14, A);
    Write('Û');
  End;
 
  GotoXY(2, HAUT + ANNEAU_NUM[1] + 1);
  For A := 2 to 78 Do Write('Û');      { Cr‚ation plancher                    }
 
  For A := 1 to ANNEAU_NUM[1] Do       { Affiche les anneaux de d‚part        }
  Begin
    ANNEAU_POSI[A, 0] := HAUT + A;                    { Assigne la rang‚e     }
    ANNEAU_POSI[A, 1] := TOUR_POSI[TOUR_SOURCE[0]];   { Assigne la colonne    }
    GotoXY(TOUR_POSI[TOUR_SOURCE[0]], HAUT + A);
    Color(A Mod 14 + 1, 1);
    Write(ANNEAU[A]);                  { Affiche l'anneau courant             }
  End;
End;
 
{-----------------------------------------------------------------------------}
Procedure Afficher_Message_Ecran;
Begin
  GotoXY(30, 1);
  Color(14, 1);
  Write('TOURS de HANOI pour ', ANNEAU_NUM[1], ' Anneau');
  If ANNEAU_NUM[1]>1 then Write('x');
  Cursor(15, 1);
End;
 
{-----------------------------------------------------------------------------}
Procedure Afficher_Mouvement;
Var
  OLD_X, OLD_Y,                        { Ancienne position X et Y             }
  NEW_X, NEW_Y : Integer;              { Nouvelle position X et Y             }
Begin
  NEW_X := TOUR_POSI[TOUR_CIBLE[NIVEAU_RECURSION]];
                             { Va … la position du prochain … d‚placer        }
  Color(15, 1);
  TOUR_HAUTEUR[TOUR_SOURCE[NIVEAU_RECURSION]] :=
    TOUR_HAUTEUR[TOUR_SOURCE[NIVEAU_RECURSION]] + 1;
  NEW_Y := TOUR_HAUTEUR[TOUR_CIBLE[NIVEAU_RECURSION]];
  OLD_Y := ANNEAU_POSI[ANNEAU_NUM[NIVEAU_RECURSION], 0];
  OLD_X := ANNEAU_POSI[ANNEAU_NUM[NIVEAU_RECURSION], 1] + 1;
  For A := OLD_Y downto HAUT Do
  Begin
    GotoXY(OLD_X - 1, A);
    Write('            Û            ');
    Cursor(15, 1);
    GotoXY(OLD_X - 1, A - 1);
    Color(ANNEAU_NUM[NIVEAU_RECURSION] Mod 14 + 1, 1);
    Write(ANNEAU[ANNEAU_NUM[NIVEAU_RECURSION]]);      { Affiche l'anneau      }
    Cursor(15, 1);
    Delay(TEMPS_Y);
  End;
  If NEW_X > OLD_X
  then For A := OLD_X Div 2 to (NEW_X + 1) Div 2 Do
       Begin
         GotoXY(A * 2, HAUT - 1);
         Color(ANNEAU_NUM[NIVEAU_RECURSION] Mod 14 + 1, 1);
         Write(ANNEAU[ANNEAU_NUM[NIVEAU_RECURSION]]); { Affiche l'anneau      }
         Cursor(15, 1);
         Delay(TEMPS_X);
         GotoXY(A * 2, HAUT - 1);
         Color(15, 1);
         Write('                         ');          { Efface l'anneau       }
         Cursor(15, 1);
       End
  else For A := (OLD_X - 1) Div 2 downto NEW_X Div 2 Do
       Begin
         GotoXY(A * 2, HAUT - 1);
         Color(ANNEAU_NUM[NIVEAU_RECURSION] Mod 14 + 1, 1);
         Write(ANNEAU[ANNEAU_NUM[NIVEAU_RECURSION]]); { Affiche l'anneau      }
         Cursor(15, 1);
         Delay(TEMPS_X);
         GotoXY(A * 2, HAUT - 1);
         Color(15, 1);
         Write('                         ');          { Efface l'anneau       }
         Cursor(15, 1);
       End;
  For A := HAUT to NEW_Y Do
  Begin
    GotoXY(NEW_X, A);
    Color(ANNEAU_NUM[NIVEAU_RECURSION] Mod 14 + 1, 1);
    Write(ANNEAU[ANNEAU_NUM[NIVEAU_RECURSION]]);      { Affiche l'anneau      }
    Cursor(15, 1);
    Delay(TEMPS_Y);
    If A <> NEW_Y then
    Begin
      Color(15, 1);
      GotoXY(NEW_X, A);
      Write('            Û            ');
      Cursor(15, 1);
    End;
  End;
 
                             { Mise … jour de la position courante de l'anneau}
  ANNEAU_POSI[ANNEAU_NUM[NIVEAU_RECURSION], 0] :=
                                   TOUR_HAUTEUR[TOUR_CIBLE[NIVEAU_RECURSION]];
  ANNEAU_POSI[ANNEAU_NUM[NIVEAU_RECURSION], 1] := NEW_X;
 
                             { D‚cr‚mente la hauteur de la tour source        }
  TOUR_HAUTEUR[TOUR_CIBLE[NIVEAU_RECURSION]] :=
                               TOUR_HAUTEUR[TOUR_CIBLE[NIVEAU_RECURSION]] - 1;
End;
 
{-----------------------------------------------------------------------------}
Procedure Executer_Mouvement(Var NB_MOUVEMENT : Integer);
Begin
  NIVEAU_RECURSION := NIVEAU_RECURSION + 1;
  If ANNEAU_NUM[NIVEAU_RECURSION] = 0
  then NIVEAU_RECURSION := NIVEAU_RECURSION - 1
  else Begin
         ANNEAU_NUM[NIVEAU_RECURSION + 1] := ANNEAU_NUM[NIVEAU_RECURSION] - 1;
         TOUR_SOURCE[NIVEAU_RECURSION + 1] := TOUR_SOURCE[NIVEAU_RECURSION];
         TOUR_CIBLE[NIVEAU_RECURSION + 1] := 6 -
           TOUR_SOURCE[NIVEAU_RECURSION] - TOUR_CIBLE[NIVEAU_RECURSION];
         Executer_Mouvement(NB_MOUVEMENT);
         NB_MOUVEMENT := NB_MOUVEMENT + 1;
         Afficher_Mouvement;
         ANNEAU_NUM[NIVEAU_RECURSION + 1] := ANNEAU_NUM[NIVEAU_RECURSION] - 1;
         TOUR_SOURCE[NIVEAU_RECURSION + 1] := 6 -
           TOUR_SOURCE[NIVEAU_RECURSION] - TOUR_CIBLE[NIVEAU_RECURSION];
         TOUR_CIBLE[NIVEAU_RECURSION + 1] := TOUR_CIBLE[NIVEAU_RECURSION];
         Executer_Mouvement(NB_MOUVEMENT);
         NIVEAU_RECURSION := NIVEAU_RECURSION - 1;
       End;
End;
 
{ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿}
{³                            Programme principal                            ³}
{ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ}
 
Begin
  IK := #1; 
  While IK <> #27 Do
  Begin
    NB_MOUVEMENT := 0;
    TEMPS_X:=10000; TEMPS_Y:=20000;
    Initialiser;                       { Initialise variables                 }
    Afficher_Message_Ecran;
    GotoXY(1, 3);
    Write('Vitesse de d‚placement = ',VITESSE);
    Afficher_Temps(5, 'Temps de d‚part = ');
    If TOUR_SOURCE[0] <> TOUR_CIBLE[0] then
    Begin
      For B := 1 to 3 Do TOUR_HAUTEUR[B] := 0;
      TOUR_HAUTEUR[TOUR_SOURCE[0]] := HAUT;
      TOUR_HAUTEUR[TOUR_CIBLE[0]]  := BASE;
      For B := 1 to 3 Do If TOUR_HAUTEUR[B] = 0 then
      Begin
        TOUR_HAUTEUR[B] := BASE;
        B := 3;
      End;
      TOUR_SOURCE[1]   := TOUR_SOURCE[0];
      TOUR_CIBLE[1]    := TOUR_CIBLE[0];
      NIVEAU_RECURSION := 0;
      Executer_Mouvement(NB_MOUVEMENT);
    End;
    Color(15, 1);
    Afficher_Temps(6, 'Temps d'+#39+'arriv‚e = ');
    GotoXY(1, 24);
    Write('PŠse TAB pour Continuer');
    GotoXY(1, 25);
    Write('PŠse ESC pour Sortir');
    Color(14, 1);
    GotoXY(40, 24);
    Write('Termin‚ en ', NB_MOUVEMENT, ' Mouvement');
    If NB_MOUVEMENT>1 then Write('s');
    Cursor(14, 1);
    IK := ReadKey;
  End;
End.

[diden138]

J'ai fait un BAC en informatique de génie à l'Université Laval entre 1990-1994

Un programme que j'avais à remettre dans le cours d'Infographie IFT10558 à l'automne 1992

J'ai eu 95% comme résultat de ce programme

Excusez, pour les caractères spéciaux du style éèêâà, ils vont vous paraître tout bizarre car je n'ai pas le temps de réécrire le programme en mode texte. Il vient directement du code BP7 et j'ai fait attention pour ce travail de bien aérer les lignes de code, ce que je fais moins en pratique pour mes applications personnelles et question d'un visuel plus rapide.

Vous verrez que je suis aussi capable de documenter pleinement un programme, mais que dans des big programmes avec plusieurs overlay, 50000 lignes de codes, le moindre caractère de documentation diminue l'espace mémoire pour compiler ce dit programme.

Pour plus de facilité de lecture j'écris plusieurs commandes sur la même ligne pour avoir un visuel plus rapide.

Sur une demie douzaine de mes programmes que j'utilise à tous les jours, la moindre ligne de code inutile, de terme trop long ou trop documentée, diminue le nombre de variable à utiliser.

Autre chose, l'informatique n'est pas mon travail, je programme par plaisir à la maison et mon boulot est la mécanique moto

Alors le fait que les gens puissent comprendre ou non mes programmes m'importe peu, l'important est qu'après 10 ans, je peu relire mes programmes comme si je les avait écris la veille et c'est ce qui se passe.

A part l'Université, je n'ai jamais fait de programmes pour les autres ou dans quelques cas rare ou des gens en Maitrise Informatique en arrachait avec du code vu qu'ils étaient plus spécialisé organigramme sur tableau que faire du code.

Ma facon de nommer les fonctions et procédures est pareille pour tout mes programmes et en plus j'utilise en commun des groupes de fonctions et de procédures pour une trentaine de programmes.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
 
Program TP6;                           { Tours de Hanoi                       }
 
{ Ce programme a ‚t‚ r‚alis‚ dans le mode texte et montre une application     }
{ du principe de la r‚cursivit‚ utilis‚ en informatique.                      }
{                                                                             }
{ Au d‚part 4 questions sont demand‚es … l'utilisateur:                       }
{                  - Le nombre d'anneaux.                                     }
{                  - La tour source.                                          }
{                  - La tour cible.                                           }
{                  - La vitesse de d‚placement de l'anneau.                   }
{                                                                             }
{ Au d‚but, la vitesse, le temps de d‚part et les anneaux sont affich‚s       }
{                                                                             }
{ A la fin, le temps d'arriv‚e, le nombre de mouvement ex‚cut‚ et             }
{ la nouvelle position des anneaux sont affich‚s, et un menu demande          }
{ la prochaine op‚ration … ex‚cuter:                                          }
{                  - PŠse ESC pour Sortir                                     }
{                  - PŠse TAB pour Continuer                                  }
 
Uses
  Crt, Dos;
Const
  BASE          =    20;               { Plancher des 3 Tours                 }
  LIGNE_BASSE   =    24;               { Ligne du bas de l'‚cran              }
  NB_ANNEAU_MAX =    12;               { Nombre maximum d'anneau              }
  TOUR_POSI                            { Position en X des 3 Tours            }
  : Array[1..3] of Integer = (2, 28, 54);
 
Type
  Matrice_A     = Array[0..NB_ANNEAU_MAX + 1] of Integer;
  Matrice_B     = Array[1..NB_ANNEAU_MAX, 0..1] of Integer;
  Matrice_C     = Array[1..3] of Integer;
  Matrice_S     = Array[1..NB_ANNEAU_MAX + 1] of String[NB_ANNEAU_MAX * 2 + 1];
 
Var
  IK               : Char;             { Cl‚ lu du clavier                    }
  A, B,                                { Compteurs divers                     }
  HAUT,                                { Plafond des tours                    }
  NB_MOUVEMENT,                        { Indicateur du nombre de mouvement    }
  NIVEAU_RECURSION,                    { Niveau de r‚cursivit‚ de proc‚dure   }
  TEMPS_X,                             { Temps de d‚placement en X            }
  TEMPS_Y,                             { Temps de d‚placement en Y            }
  VITESSE          : Integer;          { Vitesse de d‚placement des anneaux   }
  ANNEAU           : Matrice_S;        { Dessin des anneaux                   }
  ANNEAU_NUM,                          { Num‚ro des anneaux                   }
  TOUR_SOURCE,                         { Tour Source                          }
  TOUR_CIBLE       : Matrice_A;        { Tour Cible                           }
  ANNEAU_POSI      : Matrice_B;        { Position des anneaux                 }
  TOUR_HAUTEUR     : Matrice_C;        { Hauteur des Tours                    }
 
{ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿}
{³                                Fonction TP2                               ³}
{ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ}
{-----------------------------------------------------------------------------}
Function StrNombre(NOMBRE : Integer) : String;
{ Transformation d'un nombre entier en une chaine de 2 caractŠres.            }
{ Analogie de la proc‚dure Str interdite                                      }
Var
  A, B   : Byte;
  CHAINE : String;
Begin
  B      := 10;
  CHAINE := '';
  For A := 1 to 2 Do
  Begin
    CHAINE := CHAINE + Chr(NOMBRE Div B + 48);
    NOMBRE := NOMBRE Mod B;
    B      := B Div 10;
  End;
  StrNombre := CHAINE;
End;
 
{-----------------------------------------------------------------------------}
Function ValChaine(CHAINE_1 : String) : Integer;
{ Transformation d'une chaine de 4 caractŠres en nombre entier.               }
{ Analogie de la proc‚dure Val interdite                                      }
Var
  A                       : Byte;      { Compteur                             }
  MULTIPLICATEUR, NOMBRE  : Integer;
Begin
  NOMBRE         := 0;
  MULTIPLICATEUR := 1000;
  For A := 1 to 4 Do
  Begin
    NOMBRE         := NOMBRE + (Ord(CHAINE_1[A]) - 48) * MULTIPLICATEUR;
    MULTIPLICATEUR := MULTIPLICATEUR Div 10;
  End;
  ValChaine := NOMBRE;
End;
 
{ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿}
{³                               Proc‚dure TP2                               ³}
{ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ}
{-----------------------------------------------------------------------------}
Procedure Valider_Entier(Var NOMBRE  : Integer;  { Coordonn‚e format entier   }
                             MINIMUM,            { Nombre limite min permis   }
                             MAXIMUM : Integer); { Nombre limite max permis   }
Const
  CHIFFRE : Set of '0'..'9' = ['0','1','2','3','4','5','6','7','8','9'];
Var
  EFFACE, A, LONGEUR : Byte;           { Efface, Compteur, longueur CHAINE_1  }
  INKEY              : Char;           { CaractŠre lu du clavier              }
  CHAINE_1, CHAINE_2 : String;         { Sert pour r‚ajustement de CHAINE_1   }
Begin
  EFFACE := 1;
  While (EFFACE = 1) or (LONGEUR > 4) Do
  Begin
    INKEY    := #1;
    LONGEUR  := 0;
    CHAINE_1 := '';
    While (INKEY <> #13) and (LONGEUR < 5) Do
    Begin                    { Lecture du clavier                             }
      Write(' ',#8);
      INKEY := ReadKey;      { ReadKey indispensable pour l'invisibilit‚      }
      If (INKEY = #8) and (LONGEUR > 0)
      then Begin             { Effacement du dernier caractŠre de la CHAINE_1 }
             LONGEUR := LONGEUR - 1;
             Write(#8,' ',#8);
             CHAINE_2 := '';
             For A := 1 to LONGEUR Do CHAINE_2 := CHAINE_2 + CHAINE_1[A];
             CHAINE_1 := CHAINE_2;
           End
      else If CHIFFRE * [INKEY] <> [] then
           Begin             { Ajout d'un nouveau caractŠre … la CHAINE_1     }
             LONGEUR := LONGEUR + 1;
             CHAINE_1 := CHAINE_1 + INKEY;
             Write(INKEY);
           End;
    End;
    If CHAINE_1 = '' then Write('0');
                             { Si Enter sans caractŠre, NOMBRE sera 0         }
    If LONGEUR > 4
    then EFFACE := 1         { Message pour effacer CHAINE_1                  }
    else Begin               { Ajustement … 4 caractŠres de CHAINE_1          }
           For A := 1 to 4 - LONGEUR Do CHAINE_1 := '0' + CHAINE_1;
           If (ValChaine(CHAINE_1) > MAXIMUM)
           or (ValChaine(CHAINE_1) < MINIMUM)
           then EFFACE := 1            { Message pour effacer CHAINE_1        }
           else EFFACE := 0;           { Message pour valider CHAINE_1        }
         End;
    If EFFACE = 1 then                 { Efface CHAINE_1                      }
    For A := 1 to LONGEUR Do Write(#8,' ',#8);
  End;
  NOMBRE := ValChaine(CHAINE_1);       { Conversion num‚rique de CHAINE_1     }
End;
 
{ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿}
{³                               Proc‚dure TP6                               ³}
{ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ}
{-----------------------------------------------------------------------------}
Procedure Afficher_Temps(LY : Byte; CHAINE : String);
{ GetTime mˆme si interdit est la seule facon de mesurer le temps sur PC      }
Var
  HEURE, MINUTE, SECONDE, SEC100 : Word;
Begin
  GetTime(HEURE, MINUTE, SECONDE, SEC100);
  GotoXY(1, LY);
  Write(CHAINE);
  If HEURE < 10 then Write('0', HEURE) else Write(HEURE:2);
  If MINUTE < 10 then Write(':0', MINUTE) else Write(':', MINUTE:2);
  If SECONDE < 10 then Write(':0', SECONDE) else Write(':', SECONDE:2);
End;
 
{-----------------------------------------------------------------------------}
Procedure Color(A, B : Byte);          { Analogie de Color(a,b) de BASIC      }
Begin
  Textcolor(A);
  TextBackground(B);
End;
 
{-----------------------------------------------------------------------------}
Procedure Cursor(A, B : Byte);         { Efface le curseur aprŠs affichage    }
Begin
  Color(B, B);
  Write(' ', #8);
  Color(A, B);
End;
 
{-----------------------------------------------------------------------------}
Procedure Initialiser; { Initialise l'‚cran et obtient le nombre d'anneau     }
Begin
  Color(15, 1);                         { Initialise la couleur de l'‚cran     }
  ClrScr;
  Color(12, 1);
  GotoXY(30, 1);
  Write('TOURS de HANOI');             { Affiche le nom du programme          }
  Cursor(14, 1);
  GotoXY(1, 24);
  Write('Nombre d', #39, 'Anneau (1 … ', StrNombre(NB_ANNEAU_MAX), ') ');
  Cursor(14, 1);
  GotoXY(26, 24);
  Valider_Entier(ANNEAU_NUM[1], 0, NB_ANNEAU_MAX);
  GotoXY(1, 24);
  Write(' ':79);                       { Nettoie la ligne de commande         }
  GotoXY(1, 24);
  Write('Entrer le num‚ro de la tour source (1 … 3) ');
  Valider_Entier(TOUR_SOURCE[0], 1, 3);
  GotoXY(1, 24);
  Write(' ':79);
  GotoXY(1, 24);
  Write('Entrer le num‚ro de la tour cible (1 … 3) ');
  Valider_Entier(TOUR_CIBLE[0], 1, 3);
  GotoXY(1, 24);
  Write(' ':79);
  GotoXY(1, 24);
  Write('Entrer la vitesse de d‚placement ( 1=>10000æsec  …  4=>1 æsec) ');
  Valider_Entier(VITESSE, 1, 4);
  GotoXY(1, 24);
  Write(' ':79);
  Color(15, 1);
  For A := 1 to VITESSE Do
  Begin TEMPS_X:=TEMPS_X Div 10; TEMPS_Y:=TEMPS_Y Div 10; End;
 
  For A := 1 to ANNEAU_NUM[1] Do
  Begin                                { Cr‚ation des anneaux                 }
    ANNEAU[A] :='';
    For B := 1 to NB_ANNEAU_MAX * 2 + 1 Do ANNEAU[A] := ANNEAU[A] + ' ';
    For B := NB_ANNEAU_MAX + 1 - A to NB_ANNEAU_MAX + A + 1 Do
      ANNEAU[A, B] := #219;
  End;
 
  HAUT := BASE - ANNEAU_NUM[1];
  For A := HAUT to HAUT + ANNEAU_NUM[1] Do for B := 0 to 2 Do
  Begin                                { Cr‚ation des tours                   }
    GotoXY(B * 26 + 14, A);
    Write('Û');
  End;
 
  GotoXY(2, HAUT + ANNEAU_NUM[1] + 1);
  For A := 2 to 78 Do Write('Û');      { Cr‚ation plancher                    }
 
  For A := 1 to ANNEAU_NUM[1] Do       { Affiche les anneaux de d‚part        }
  Begin
    ANNEAU_POSI[A, 0] := HAUT + A;                    { Assigne la rang‚e     }
    ANNEAU_POSI[A, 1] := TOUR_POSI[TOUR_SOURCE[0]];   { Assigne la colonne    }
    GotoXY(TOUR_POSI[TOUR_SOURCE[0]], HAUT + A);
    Color(A Mod 14 + 1, 1);
    Write(ANNEAU[A]);                  { Affiche l'anneau courant             }
  End;
End;
 
{-----------------------------------------------------------------------------}
Procedure Afficher_Message_Ecran;
Begin
  GotoXY(30, 1);
  Color(14, 1);
  Write('TOURS de HANOI pour ', ANNEAU_NUM[1], ' Anneau');
  If ANNEAU_NUM[1]>1 then Write('x');
  Cursor(15, 1);
End;
 
{-----------------------------------------------------------------------------}
Procedure Afficher_Mouvement;
Var
  OLD_X, OLD_Y,                        { Ancienne position X et Y             }
  NEW_X, NEW_Y : Integer;              { Nouvelle position X et Y             }
Begin
  NEW_X := TOUR_POSI[TOUR_CIBLE[NIVEAU_RECURSION]];
                             { Va … la position du prochain … d‚placer        }
  Color(15, 1);
  TOUR_HAUTEUR[TOUR_SOURCE[NIVEAU_RECURSION]] :=
    TOUR_HAUTEUR[TOUR_SOURCE[NIVEAU_RECURSION]] + 1;
  NEW_Y := TOUR_HAUTEUR[TOUR_CIBLE[NIVEAU_RECURSION]];
  OLD_Y := ANNEAU_POSI[ANNEAU_NUM[NIVEAU_RECURSION], 0];
  OLD_X := ANNEAU_POSI[ANNEAU_NUM[NIVEAU_RECURSION], 1] + 1;
  For A := OLD_Y downto HAUT Do
  Begin
    GotoXY(OLD_X - 1, A);
    Write('            Û            ');
    Cursor(15, 1);
    GotoXY(OLD_X - 1, A - 1);
    Color(ANNEAU_NUM[NIVEAU_RECURSION] Mod 14 + 1, 1);
    Write(ANNEAU[ANNEAU_NUM[NIVEAU_RECURSION]]);      { Affiche l'anneau      }
    Cursor(15, 1);
    Delay(TEMPS_Y);
  End;
  If NEW_X > OLD_X
  then For A := OLD_X Div 2 to (NEW_X + 1) Div 2 Do
       Begin
         GotoXY(A * 2, HAUT - 1);
         Color(ANNEAU_NUM[NIVEAU_RECURSION] Mod 14 + 1, 1);
         Write(ANNEAU[ANNEAU_NUM[NIVEAU_RECURSION]]); { Affiche l'anneau      }
         Cursor(15, 1);
         Delay(TEMPS_X);
         GotoXY(A * 2, HAUT - 1);
         Color(15, 1);
         Write('                         ');          { Efface l'anneau       }
         Cursor(15, 1);
       End
  else For A := (OLD_X - 1) Div 2 downto NEW_X Div 2 Do
       Begin
         GotoXY(A * 2, HAUT - 1);
         Color(ANNEAU_NUM[NIVEAU_RECURSION] Mod 14 + 1, 1);
         Write(ANNEAU[ANNEAU_NUM[NIVEAU_RECURSION]]); { Affiche l'anneau      }
         Cursor(15, 1);
         Delay(TEMPS_X);
         GotoXY(A * 2, HAUT - 1);
         Color(15, 1);
         Write('                         ');          { Efface l'anneau       }
         Cursor(15, 1);
       End;
  For A := HAUT to NEW_Y Do
  Begin
    GotoXY(NEW_X, A);
    Color(ANNEAU_NUM[NIVEAU_RECURSION] Mod 14 + 1, 1);
    Write(ANNEAU[ANNEAU_NUM[NIVEAU_RECURSION]]);      { Affiche l'anneau      }
    Cursor(15, 1);
    Delay(TEMPS_Y);
    If A <> NEW_Y then
    Begin
      Color(15, 1);
      GotoXY(NEW_X, A);
      Write('            Û            ');
      Cursor(15, 1);
    End;
  End;
 
                             { Mise … jour de la position courante de l'anneau}
  ANNEAU_POSI[ANNEAU_NUM[NIVEAU_RECURSION], 0] :=
                                   TOUR_HAUTEUR[TOUR_CIBLE[NIVEAU_RECURSION]];
  ANNEAU_POSI[ANNEAU_NUM[NIVEAU_RECURSION], 1] := NEW_X;
 
                             { D‚cr‚mente la hauteur de la tour source        }
  TOUR_HAUTEUR[TOUR_CIBLE[NIVEAU_RECURSION]] :=
                               TOUR_HAUTEUR[TOUR_CIBLE[NIVEAU_RECURSION]] - 1;
End;
 
{-----------------------------------------------------------------------------}
Procedure Executer_Mouvement(Var NB_MOUVEMENT : Integer);
Begin
  NIVEAU_RECURSION := NIVEAU_RECURSION + 1;
  If ANNEAU_NUM[NIVEAU_RECURSION] = 0
  then NIVEAU_RECURSION := NIVEAU_RECURSION - 1
  else Begin
         ANNEAU_NUM[NIVEAU_RECURSION + 1] := ANNEAU_NUM[NIVEAU_RECURSION] - 1;
         TOUR_SOURCE[NIVEAU_RECURSION + 1] := TOUR_SOURCE[NIVEAU_RECURSION];
         TOUR_CIBLE[NIVEAU_RECURSION + 1] := 6 -
           TOUR_SOURCE[NIVEAU_RECURSION] - TOUR_CIBLE[NIVEAU_RECURSION];
         Executer_Mouvement(NB_MOUVEMENT);
         NB_MOUVEMENT := NB_MOUVEMENT + 1;
         Afficher_Mouvement;
         ANNEAU_NUM[NIVEAU_RECURSION + 1] := ANNEAU_NUM[NIVEAU_RECURSION] - 1;
         TOUR_SOURCE[NIVEAU_RECURSION + 1] := 6 -
           TOUR_SOURCE[NIVEAU_RECURSION] - TOUR_CIBLE[NIVEAU_RECURSION];
         TOUR_CIBLE[NIVEAU_RECURSION + 1] := TOUR_CIBLE[NIVEAU_RECURSION];
         Executer_Mouvement(NB_MOUVEMENT);
         NIVEAU_RECURSION := NIVEAU_RECURSION - 1;
       End;
End;
 
{ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿}
{³                            Programme principal                            ³}
{ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ}
 
Begin
  IK := #1; 
  While IK <> #27 Do
  Begin
    NB_MOUVEMENT := 0;
    TEMPS_X:=10000; TEMPS_Y:=20000;
    Initialiser;                       { Initialise variables                 }
    Afficher_Message_Ecran;
    GotoXY(1, 3);
    Write('Vitesse de d‚placement = ',VITESSE);
    Afficher_Temps(5, 'Temps de d‚part = ');
    If TOUR_SOURCE[0] <> TOUR_CIBLE[0] then
    Begin
      For B := 1 to 3 Do TOUR_HAUTEUR[B] := 0;
      TOUR_HAUTEUR[TOUR_SOURCE[0]] := HAUT;
      TOUR_HAUTEUR[TOUR_CIBLE[0]]  := BASE;
      For B := 1 to 3 Do If TOUR_HAUTEUR[B] = 0 then
      Begin
        TOUR_HAUTEUR[B] := BASE;
        B := 3;
      End;
      TOUR_SOURCE[1]   := TOUR_SOURCE[0];
      TOUR_CIBLE[1]    := TOUR_CIBLE[0];
      NIVEAU_RECURSION := 0;
      Executer_Mouvement(NB_MOUVEMENT);
    End;
    Color(15, 1);
    Afficher_Temps(6, 'Temps d'+#39+'arriv‚e = ');
    GotoXY(1, 24);
    Write('PŠse TAB pour Continuer');
    GotoXY(1, 25);
    Write('PŠse ESC pour Sortir');
    Color(14, 1);
    GotoXY(40, 24);
    Write('Termin‚ en ', NB_MOUVEMENT, ' Mouvement');
    If NB_MOUVEMENT>1 then Write('s');
    Cursor(14, 1);
    IK := ReadKey;
  End;
End.

bonjour,
d'abord la programmation est un art, qui dit art dit passion, donc on peut pas faire de la prog sans aimer ça donc programmeur du dimanche ou étudiant ou pro il faut respecter quelques règles que droggo a rappelé .
j'ajoute qu'à ma connaissance les commentaires ne consomment pas d'espace mémoire et même si t'en métrais 10.000 lignes tout simplement parce que le compilateur élimine tout seul les commentaire+caractères superflus(espace,tabulation...etc) lors de l'analyse lexical de ton programme .
en espérant de t'avoir convaincu un peu .
cordialement @+

[droggo]

Fie,

Je vais ajouter une petite remarque : il éviter d'utiliser massivement les majuscules, car, c'est démontré par des tests très sérieux, on lit plus facilement/rapidement les minuscules (d'un facteur de temps de lecture proche de 1.5 !!).

Des noms entièrement en majuscules sont donc à éviter, ou du moins à réserver à quelques cas (les constantes, par exemple, comme c'est l'habitude en C ou C++). Ensuite, pour distinguer au 1er coup d'oeil variables et procédures/fonctions, on peut par exemple décider que les noms des procédures/fonctions commencent par une majuscule, et les noms de variables par une minuscule (ce n'est qu'une des possibilités, évidemment).

[Transgarp]

@ Droggo

J'évite normalement d'écrire en majuscule.

Ce qui me parait naturel comme nom de fonction ou de procédure est d'écrire la première lettre par une majuscule pour que mon oeil la situe plus rapidement dans le code.

Et vous avez du remarquer dans mon petit travail d'Université des "Tours de Hanoi" que j'aime bien décaler la marge du code quand j'entre plus profondément dans des bloc Begin...End; Un autre truc qui me facilite la lecture du code.

Je continue à soutenir que les fonctions ou procédures se commente d'elle même quand on leur choisit un nom approprié du style

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Procedure Afficher_Temps(LY : Byte; CHAINE : String);

au lieu d'écrire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Procedure A001(LY : Byte; CHAINE : String);

et que des commentaires supplémentaires n'ajoute que de la redondance.


@diden138

Il y a justement une limite au poids d'un programme, ca se situe à 70Koctets environ, le pourquoi j'utilise des Overlay. Même à ca j'ai certains programmes que je ne peu overlay et j'optimise le plus possible en diminuant les commentaires et la longueur des noms de fonctions ou de procédures.

C'est peux-être différent avec vos nouveaux compilateurs, mais BP7 me force à agir de la sorte.


@Tout le monde

A l'Université les profs nous obligeaient à écrire une fonction ou procédure par ligne de code.

A la maison je préfère utiliser la plage maximum aloué par BP7 qui se situe à environ 120 caractères pour ajouter autant de fonctions ou procédures qu'il m'est possible d'ajouter sans dépasser la fin de ligne.

Le seul moment que je décalle est dans le cas des If...then...else Repeat...Until ou tout corps de fonctions ou de procédures

Finalement je peu écrire jusqu'à 8 commandes sur la même ligne et quand je parle que j'ai des programmes qui ont 20,000 lignes de code, je devrais traduire par 160,000 ligne de codes selon votre facon d'écrire du code

genre ca

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
    For CX:=0 to 4 Do
    Begin
      Open_N50(CX,FS); Rewrite(N50f); N50b.S:=Strings(46,' '); N50b.L:=1; Write(N50f,N50b); Close(N50f); Ja[CX]:=0;
    End;

Et c'est quoi cette manie qu'on a de programmer en antique Pascal quand tout le monde passe à des langages plus moderne de style Delphi ou autre ??

Les cacagénères comme moi je peu comprendre, mais vous les jeunes en bas de 30 ans, je ne comprends vraiment pas

[diden138]

Il y a justement une limite au poids d'un programme, ca se situe à 70Koctets environ, le pourquoi j'utilise des Overlay. Même à ca j'ai certains programmes que je ne peu overlay et j'optimise le plus possible en diminuant les commentaires et la longueur des noms de fonctions ou de procédures.

C'est peux-être différent avec vos nouveaux compilateurs, mais BP7 me force à agir de la sorte.

je savais pas ça tu parle de limite de la taille d'un code source c'est ça ?
ou de la longueur d'une chaine dans un code source si c'est cette dernière je sais par exemple en pascal c'est limité à 256 caractère.
si c'est la première ben c'est une première jamais entendu parler de ça
donc si j'ai bien compris un code qui fait plus de 20.000ligne par exemple ne peut être écrit du moins dans une seul fichier ?

Et c'est quoi cette manie qu'on a de programmer en antique Pascal quand tout le monde passe à des langages plus moderne de style Delphi ou autre ??

parce que:
1-de nos jours on construit des programme de plus en plus complexe d'où la nécessité de bien respecter quelques règles.
2-c'est plus facile de s'y trouver que tu le veuille ou non .
3...etc
n parce que c'est zoli .
cordialement @+

[droggo]

Dio,

J'évite normalement d'écrire en majuscule.

Ce n'est pas franchement ce qui ressort de ton code.

Et vous avez du remarquer dans mon petit travail d'Université des "Tours de Hanoi" que j'aime bien décaler la marge du code quand j'entre plus profondément dans des bloc Begin...End; Un autre truc qui me facilite la lecture du code.

Oui, et c'est bien. Ça s'appelle indenter le code, et le but en est bien de rendre le code plus lisible, pas de faire beau.

Il y a justement une limite au poids d'un programme, ca se situe à 70Koctets environ, le pourquoi j'utilise des Overlay. Même à ca j'ai certains programmes que je ne peu overlay et j'optimise le plus possible en diminuant les commentaires et la longueur des noms de fonctions ou de procédures.

C'est peux-être différent avec vos nouveaux compilateurs, mais BP7 me force à agir de la sorte.

De quelle limite parles-tu ?

- S'il s'agit de la taille du programme exécutable, elle peut être nettement plus grande, et les commentaires et noms de procédures n'y ont plus aucune pertinence (les commentaires sont purement et simplement exclus de l'exécutable, et les noms de procédures/variables... se résument à une adresse.

- S'il s'agit de la taille d'un fichier source pour le code, quand ça atteint de telles tailles, c'est qu'il fallait penser à découper le tout en unités regroupant les procédures de manière logique (ça a été crée dans ce but).

A l'Université les profs nous obligeaient à écrire une fonction ou procédure par ligne de code.

A la maison je préfère utiliser la plage maximum aloué par BP7 qui se situe à environ 120 caractères pour ajouter autant de fonctions ou procédures qu'il m'est possible d'ajouter sans dépasser la fin de ligne.

Finalement je peu écrire jusqu'à 8 commandes sur la même ligne et quand je parle que j'ai des programmes qui ont 20,000 lignes de code, je devrais traduire par 160,000 ligne de codes selon votre facon d'écrire du code

Ça peut se discuter, mais il y a bien longtemps qu'on recommande
1 instruction = 1 ligne
et les profs ont raison, pour la clarté du code, une fois de plus.

Et c'est quoi cette manie qu'on a de programmer en antique Pascal quand tout le monde passe à des langages plus moderne de style Delphi ou autre

Là, je suis en plein accord avec toi (comme quoi il ne faut jamais désespérer ).

Sauf (faut bien que je soigne ma réputation ) que Delphi n'est pas un autre langage, c'est du Pascal. Ce qui diffère, c'est que Delphi fourni la VCL, de quoi construire aisément des applications avec une interface graphique.

[Transgarp]

donc si j'ai bien compris un code qui fait plus de 20.000ligne par exemple ne peut être écrit du moins dans une seul fichier ?

Oui, je parle du poids du code source, il y a une limite de 70K environ, que ce soit du code ou des commentaires, alors je préfère y placer plus de code que des commentaires.

J'ai résolu mon problème de limite de fichier en BP7 en ayant des noms de commande qui s'auto-documente.

Dans le cas de mon programme de généalogie GPG.PAS, je n'avais pas le choix de batir des Unit, en plus ca aide à la structure et à la lisibilité du programme de ne pas tout mettre dans le corps du programme principal.

Le code source du programme GPG pèse 530 Koctets et optimisé au maximum, redondance zéro.

Petit exemple de l'unit GPG_CONS.PAS pour des constantes utilisées par les autres unit et le programme principal GPG.PAS

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
Unit GPG_CONS;
 
Interface
 
Const
  ENFANT  = 16;
  ETAT         : Array[0..1] of String[3] = ('OFF','ON ');
  S10     = '          ';
  FI      : Array[0..1] of String = ('D:\TMP\G90.DAT','D:\TMP\G91.DAT');
  FJ      : Array[0..8] of String = ('D:\TMP\G00.DAT','D:\TMP\G01.DAT',
                                     'D:\TMP\G02.DAT','D:\TMP\G03.DAT',
                                     'D:\TMP\G04.DAT','D:\TMP\G05.DAT',
                                     'D:\TMP\G06.DAT','D:\TMP\G07.DAT',
                                     'D:\TMP\G08.DAT');
  FW                              = 'D:\GRP\DOC\GPG\GPG_TREE.DOC';
  FEUILLE : Array[1..4] of String[31] = ('ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿',
                                         '³                             ³',
                                         '³                             ³',
                                         'ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ');
 
Implementation
 
End.

[Transgarp]

Finalement, ce petit programme GPG.PAS que j'ai commencé en 1990 et fait grandir depuis, me permet de mettre en ligne sur internet mon arbre généalogique et ma base de données généalogique.

J'y fait toujours des améliorations quand j'en juge le besoin.


http://gpg.dyndns.org/gpg/WOOD/W00001.HTM

http://gpg.dyndns.org/gpg/INDEX_INDEX.HTM

[droggo]

Gio,

Oui, je parle du poids du code source, il y a une limite de 70K environ, que ce soit du code ou des commentaires, alors je préfère y placer plus de code que des commentaires.

J'ai résolu mon problème de limite de fichier en BP7 en ayant des noms de commande qui s'auto-documente.

Là, je suis désolé, mais t'être emme*** avec cette limite est ridicule.

Un fichier source qui arrive à 64K est un fichier pour un programme mal conçu : il faut découper en unités logiques plus petites, etc.

Tu l'as fait pour un autre programme plus gros parce que tu ne t'en sortais plus. C'est la parfaite démonstration que ce découpage est à faire systématiquement, ne serait-ce que pour éviter d'avoir à se balader dans de si longs fichiers sources, et pour faciliter l'éventuelle réutilisation des morceaux dans d'autres programmes.

------------------------

Et puisque tu parles des overlay, ils n'ont absolument rien à voir avec ce problème, alors que tu sembles bien lier les 2.
L'overlay (au sens de TP), c'est séparer l'exécutable en plusieurs morceaux, afin de ne charger en mémoire que ce dont on a besoin à un moment donné.
Rien à voir donc avec le code source.

------------------------

Petit exemple de l'unit GPG_CONS.PAS pour des constantes utilisées par les autres unit et le programme principal GPG.PAS

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
Unit GPG_CONS;
 
Interface
 
Const
  ENFANT  = 16;
  ETAT         : Array[0..1] of String[3] = ('OFF','ON ');
  S10     = '          ';
  FI      : Array[0..1] of String = ('D:\TMP\G90.DAT','D:\TMP\G91.DAT');
  FJ      : Array[0..8] of String = ('D:\TMP\G00.DAT','D:\TMP\G01.DAT',
                                     'D:\TMP\G02.DAT','D:\TMP\G03.DAT',
                                     'D:\TMP\G04.DAT','D:\TMP\G05.DAT',
                                     'D:\TMP\G06.DAT','D:\TMP\G07.DAT',
                                     'D:\TMP\G08.DAT');
  FW                              = 'D:\GRP\DOC\GPG\GPG_TREE.DOC';
  FEUILLE : Array[1..4] of String[31] = ('ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿',
                                         '³                             ³',
                                         '³                             ³',
                                         'ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ');
 
Implementation
 
End.

Si je comprends bien, tu as des données pour 1990 et 1991, une interruption, et tu as repris de 2000 à 2008.

Si tu continues l'utilisation de ton programme, il va falloir que tu changes le source pour avoir les noms des nouveaux fichiers, ...

Au passage : les limites de tableaux, etc. devraient être définies via des constantes, et pas avec des valeurs qu'on dit "magiques" dans un code source, car il n'y a pas grand chose de pire pour rendre la maintenance quasi-inextricable.

[Transgarp]

@droggo

Je n'ai jamais dit que je me suis emme... avec la limite de 64K, je programme avec les unit depuis 1990 avec mon BP7

Certains que je découpe en plus petits unit depuis que je programme en Pascal, mais c'était impossible en DOS Basica quand je programmais sur mon IBM-PC en 1984

Bon, il est allumé le gars, les overlay se charge différemment selon le mode que j'utilise en Real Mode Application ou en Protected Mode Application.

Les unit je les utilise autant en Real Mode qu'en Protected Mode

Le code que j'utilise pour différencier les 2 modes

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
30
 
Uses
{$IFDEF DPMI}
  Crt,Dos,Printer,CHR_UNIT,
  GPG_BASE,GPG_BOOK,GPG_DATA,GPG_FICH,GPG_GED,GPG_RECH,GPG_ROOT,GPG_SORT,
  GPG_TYPE,GPG_TREE,GRP_CONS,GRP_FONC,GRP_GRAP,GRP_PROC,GRP_TYPE;
{$ELSE}
  Crt,Dos,Overlay,Printer,CHR_UNIT,
  GPG_BASE,GPG_BOOK,GPG_DATA,GPG_FICH,GPG_GED,GPG_RECH,GPG_ROOT,GPG_SORT,
  GPG_TYPE,GPG_TREE,GRP_CONS,GRP_FONC,GRP_GRAP,GRP_PROC,GRP_TYPE;
{$ENDIF}
 
{$O CHR_UNIT}
{$O GPG_8514}
{$O GPG_BASE}
{$O GPG_BOOK}
{$O GPG_DATA}
{$O GPG_FICH}
{$O GPG_PROC}
{$O GPG_RECH}
{$O GPG_ROOT}
{$O GPG_SORT}
{$O GPG_TREE}
 
{$IFDEF DPMI}
{$ELSE}
  OvrInit('D:\TMP\GPG.OVR');
  If OvrResult<>OvrOk then OvrInit('D:\GRP\OVR\GPG.OVR');
  If OvrResult<>OvrOk then WriteErrorOVR;
{$ENDIF}

Qui a dit que 'D:\TMP\G90.DAT', 'D:\TMP\G91.DAT' implique l'année 90-91 ??

Petite description des fichiers DATA du programme malgré tout

Lors du SORT le logiciel s'occupe en plus de la mise en ordre binaire, de vérifier différents type d'erreurs qui m'aurait passé entre les doigts durant l'acquisition de données, comme :
- Test redondance G11.DAT, Date
- Test redondance G12.DAT, Code de famille
- Test redondance G21.DAT, Nom
- Test redondance G22.DAT, Prénom
- Test redondance G23.DAT, Toponyme
- Test redondance G24.DAT, Endroit
- Test redondance G25.DAT, Division
- Test redondance G26.DAT, Profession
- Test redondance G33.DAT, Triplet (Toponyme, Endroit, Division)
- Test redondance G44.DAT, (Date, G33)
- Test redondance G77.DAT, Fiche complète d'un individu (G11,G12,G21,G22,G23,G24,G25,G26,G44)
- Test redondance G90.DAT, Fiche complète d'un couple femme-homme (G77 individu, conjoint(e), parents)
- Test redondance G91.DAT, Fiche complète d'un couple homme-femme (G77 individu, conjoint(e), parents)
- Test fichiers G90.DAT, G91.DAT Parents avec date de mariage plus récente que celle des enfants
- Test fichiers G90.DAT, G91.DAT Mariage semblable
- Test fichiers G90.DAT, G91.DAT Mariage équivalent
- Test fichiers G90.DAT, G91.DAT Mauvaise équivalence
- Test fichiers G90.DAT Parents absents
- Test fichier G01.DAT Parents en erreur
- Test fichier G01.DAT Branche coupée des parents
- Test membre de couple manquant G90.DAT, G91.DAT
Les fichiers G11,G12,G21,G22,G23,G24,G25,G26 sont de type binaire avec DATA alphanumérique
Les fichiers G01,G33,G44,G77,G90,G91 sont de type binaire avec DATA par pointeurs

Explique moi ce que signifie "valeurs magiques" que compose mon programme GPG, je ne saisis pas dutout ??

[diden138]

puisque vous en parlez des overlays
les overlays sont en quelques sorte les ancêtre des dll, une dll préhistorique on met les procedures les moins utilisées à part, dans la plus part des cas parce que la mémoire n'étais pas assez pour charger tout le programme dessu.
quand il y avait que le mode réel (640ko max) le programmeur était obligé de couper son prog mais avec l'apparition du mode protégé je ne vois pas l'intérêt puisque le mode protégé par défaut divise le programme en pages et charge que ce dont a besoin.
2éme point à ma connaissance lorsque on veut overlayser(désole pour le terme ) un programme on est obligé de travailler avec les unités car on met les proc qu'on veut overlayser( ) dans chaque unité et tu me dis que ton prog contenait plus de 20.000lignes 640ko et tu l'overloyser j'aimerais bien savoir comment ? .

Explique moi ce que signifie "valeurs magiques" que compose mon programme GPG, je ne saisis pas dutout ??

ah je pense qu'il parlais des valeur magiques tombées du ciel comme le 3 ..etc.
cordialement @+

[Transgarp]

@diden

Ouais, j'ai déjà programmé avec cette limite de 640K sur mon premier IBM-PC, la vraie misère, en plus je n'avais qu'un lecteur de disquette 5.25" 360K

Le bonheur total quand j'ai acheté mon IBM XT286 en 1986, j'avais un big disque dur de 40Meg

Le but avec les unit est justement d'utiliser le max de mémoire permise pour chaque partie de programme

N'ai crainte pour mon programme GPG, il y a 25 unit qui le compose et le 530K est le total de GPG.PAS et de tous les units.

Chaque unit ont au gros max 64K, la plus petite 3K pour un max de 2000 lignes de code par unit, selon votre facon de coder on pourrait dire que mon plus gros unit a un minimum de 10,000 lignes

[diden138]

@ Transgarp
à t'entendre on dirait qu'on est je dirais dans les année 80..91 max
tu sais les machines d'aujourd'hui ont une ram qui atteint les 2 voir 4go et on a des clé usb aussi au lieu des disquette
et j'ai un ami qui a un disque dur de 2To tu sais tera octet c'est 10^12 O
oh non ne me dis pas que tu code encore sur ton IBM
non sérieusement je préfère mettre une centaine d'unité chacune lisible et représentant de façon clair la structure du programme tu verra que tu ouvrira ton dossier tu trouvera ton programme organiser en module en quelques sorte et op je veux modifier tel fonction voila l'unité.

Le but avec les unit est justement d'utiliser le max de mémoire permise pour chaque partie de programme

pas que ça pour la réutilisabilité,diviser son programme en forme de module aussi, je dirais qu'on général t'a une vision très local de tes programmes d'après ce que je vois.
cordialement @+

[droggo]

Sio,

@droggoBon, il est allumé le gars, les overlay se charge différemment selon le mode que j'utilise en Real Mode Application ou en Protected Mode Application.

mais tu as écrit

Il y a justement une limite au poids d'un programme, ca se situe à 70Koctets environ, le pourquoi j'utilise des Overlay. Même à ca j'ai certains programmes que je ne peu overlay et j'optimise le plus possible en diminuant les commentaires et la longueur des noms de fonctions ou de procédures.

où tu parles d'overlay à propos de la limite de taille d'un fichier. Tu t'es sans doute mal exprimé, mais c'est ainsi.

Mais vu ce que tu postes comme exemple, c'est ok

Qui a dit que 'D:\TMP\G90.DAT', 'D:\TMP\G91.DAT' implique l'année 90-91 ??

Compte tenu des noms, c'était une supposition qui me paraissait raisonnable (et j'avais bien précisé "si je comprends bien").

@droggo
Explique moi ce que signifie "valeurs magiques" que compose mon programme GPG, je ne saisis pas dutout ??

C'est ce que diden138 a déjà répondu : des valeurs écrites en "dur" dans le code, au lieu d'utiliser des constantes symboliques, destinées à faciliter la maintenance du code en cas de changement.

Chaque unit ont au gros max 64K, la plus petite 3K pour un max de 2000 lignes de code par unit, selon votre facon de coder on pourrait dire que mon plus gros unit a un minimum de 10,000 lignes

Je tends à considérer que 10 000 lignes pour un fichier source, c'est beaucoup trop, mais c'est un avis personnel, bien entendu.

De plus, si tu as plus de 10 000 ligne pour ta plus grosse unité, que tu dis proche de la limite 64K, ça fait environ 6.5 caractères par ligne en moyenne ?

[Tuxico]

et que des commentaires supplémentaires n'ajoute que de la redondance.

ouhla, faut pas me faire peur comme ça

Les commentaires sont utiles dans le cas d'un algorithme qui peut paraitre complexe, dans un invariant de boucle, un invariant de données et j'en passe.
On ne commente pas à tort et à travers, on commente pour s'y retrouver plus tard et pour que les autres s'y retrouvent et le tout dans un langage le plus formel possible (pas "le tableau prends la valeur true quelque part au milieu" par exemple)


Sinon, tu parles beaucoup de ce que l'on t'as enseigné, mais l'informatique est une des branches qui devient obsolète le plus vite.
Ce que l'on t'as enseigné il y a 20 ans, est toujours correct dans les bases, mais pas forcément dans le langage en lui-même, les langages évoluent, les normes aussi.

Pour ce qui est de la taille des fichiers, tout a été dit par diden et droggo, le but n'est pas de créer un méga-fichier avec la taille maixmum admise mais bien plusieurs fichiers (packets, units, libs selon les langages) ayant chacun un domaine bien défini et étant importés dans ton programme principal.