Discussion :

[Pacorabanix]

Bonsoir !


Je suis un tout débutant en Pascal pour des cours d'info dans ma formation. J'ai d'assez bonnes bases de C/C++, un peu de java.

Donc je connais les "paradigmes" (?) de la programmation objet tout comme il faut, enfin il me semble que c'est clair dans ma tête tout ça .

Et là on me fait faire juste un cours de base sur les structures de données, donc rien de méchant à priori, pas de programmation objet.

Pourtant, malgré mon enthousiasme naïf, je me plante royalement en essayant de faire une chose assez simple : remplir une liste chainée (double) avec des éléments crées dynamiquement à l'aide d'un fichier.

je vais essayer d'être clair :

En exécutant mon code pas à pas, je réalise qu'une erreur run-time apparait lorsque j'insère un nouvel élément dans ma liste (au moment où j'appelle une fonction "insFin(liste : TListeD; element : TElem)", ou plutot pour être exacte quand cette fonction rend la main) . mais sur la console c'est "error file not open" qui s'affiche.

Je n'arrive pas à comprendre d'où vient l'erreur : du fichier, ou bien de l'utilisation de la liste ?


Voici les morceaux de code incriminés, demandez si vous avez besoin de plus d'infos. Il doit y avoir quelque chose que je n'ai pas saisi avec l'allocation dynamique :

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
PROGRAM YVTP3;

uses
   YVPile, YVListD, YVTElem, YVFich;



CONST
   NOMFICH_ENTREE = 'resPat.txt';
   NOMFICH_SORTIE = 'resPat2.txt';

VAR
   listePat : TListeDouble;
   pilePat : TPile;
   rien : string;


BEGIN
   writeln('Programme d''inversion des patineurs');
   ChargerListe(listePat, NOMFICH_ENTREE); !ERREUR ICI!
   listeAfficher(listePat);
   creerPile(pilePat, listePat);
   ecrirePile(pilePat, NOMFICH_SORTIE);
   writeln('Fin du programme');
   readln(rien);
END.

ChargerListe est un fonction de l'unité YVFich :

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
procedure chargerListe(var listePat : TListeDouble; filename : string);
var fichier : Text;
    ligne : string;
    patineur : TPatineur;
begin
      creerListe(listePat);
      assign(fichier, filename);
      reset(fichier);
      while (not eof(fichier)) do begin
          readln(fichier, ligne);
          CreerPatineur(patineur, ligne);
          insFin(listePat, patineur); <- L'ERREUR ICI
      end;
      close(fichier);
end;

la procedure CreerListe initialise ma liste avec tous les pointeurs à nil et le compte d'éléments à zéro. AU fait, voici la déclaration de ma liste :

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
UNIT YVListD;
 
INTERFACE
 
Uses YVTElem ;
 
TYPE
 
 
   TElem = TPatineur;
 
   TPNoeud = ^TNoeud;
 
   TNoeud = record
      suivant, precedent : TPNoeud;
      elem : TElem;
   end;
 
   TListeDouble = record
      debut, fin : TPNoeud;
      nbElem : integer;
      courant : TPNoeud;
   end;
 
 
 
 
{Création}
procedure CreerListe(var liste : TListeDouble);
 
 
{Modification}
procedure insDebut(var liste : TListeDouble; elem : TElem);
procedure insFin(var liste : TListeDouble; elem : TElem);

voici la procedure "CreerPatineur" (dans l'unité YVElem)

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
UNIT YVTElem;
INTERFACE
uses strings;
 
 
TYPE
 
   TPatineur = record
      prenom, nom : string;
      note : real;
   end;
 
{....}
IMPLEMENTATION
procedure creerPatineur(var pat : TPatineur; ligneFichier : string);
{ analyser la ligne de fichier et extraire le prénom, nom, et note }
var p1, p2, p3 : pChar;
chaine : pChar;
e : integer;
begin
   p1 := strNew(strPCopy(chaine, ligneFichier));
   p2 := strScan(p1, ';');
   p3 := strRScan(p1, ';');
   val(strPas(p3+1), pat.note, e);
   p1[p3-p1] := #0;
 
   pat.nom := strPas(p2+1);
   p1[p2-p1] := #0;
 
   pat.prenom := strPas(p1);
 
   write('Patineur crée : ' + pat.prenom + ' ' + pat.nom + ' ');
   write(pat.note);
   writeln();
 
   strDispose(p1);
end;

cette dernière fonctionne bien il me semble, l'affichage du résultat est correct.
J'ai fait ce truc qui me semble tordu car on nous a demandé d'"utiliser le type pChar" (je ne comprends pas trop car le type string pascal de base avait l'air d'avoir des fonctions pour ça... mais bref passons, il m'affiche un résultat correct)


et voici la procedure "InsFin" (de l'unité YVListD) où il y a l'erreur en question :

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
procedure insFin(var liste : TListeDouble; elem : TElem);
var p : ^TNoeud;
begin
   {créer un nouveau noeud et le mettre au bon endroit}
   new(p);
   p^.precedent := liste.fin;
   p^.suivant := nil;
 
   {ici au départ j'avais mis p^.elem := elem;
   j'ai finalement essayé de mettre tout le détail, mais j'ai toujours l'erreur}
   p^.elem.prenom := elem.prenom;
   p^.elem.nom := elem.nom;
   p^.elem.note := elem.note;
 
   liste.fin := p;
 
   liste.nbElem := liste.nbElem + 1;
 
end;

L'erreur se produit au moment exact de la sortie de cette procedure ! (lorsque je fais pas à pas) . Donc j'imagine que c'est un souci avec mon pointeur... mais je n'y comprends rien.

Le fichier qu'il essaye de lire :

ResPat.txt :

Code :

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

1
2
3
4
5
6
7
8
9
10
Jean;Ballin;3.5
Marc;Artan;4.5
Gilles;Deschamps;3.8
Marte;Gillot;4.7
Arnaud;Clement;5.5
Juliette;Carnot;5.9
Mireille;Ony;3.2
Marie;Gontro;4.9
Eric;Durant;5.3
Annie;Tautoo;5.5

Voici les sorties et messages d'erreur que j'obtiens:

lorsque je débug pas à pas ou lorsque je lance le programme d'un trait depuis FreePascal :

(au moment de la sortie de la procedure insFin() )
pop-up :Warning
Run Time Error 4221795
Error address $00414F04
voici le stack :

Code :

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

1
2
3
4
5
6
7
8
 00406EB0 SYSTEM_HANDLEERRORADDRFRAME$LONGINT$POINTER$POINTER ()
 00406F6D SYSTEM_HANDLEERRORFRAME$LONGINT$POINTER ()
 004143C4 U_SYSTEM_OUTPUT ()
 00415B74 U_SYSINITPAS_ENTRYINFORMATION ()
 00414F04 U_SYSTEM_ENTRYINFORMATION ()
 00406B63 fpc_iocheck ()
 yvfich.pas(25) CHARGERLISTE (LISTEPAT={DEBUT = $0, FIN = $0, NBELEM = 0, COU
 yvtp3.pas(20) main ()

puis program exited with code 217

Voici l'affichage de la console :

Code :

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

1
2
3
4
5
6
Programme d'inversion des patineurs
Patineur crée : Jean Ballin  3.50000000000000E+000
An unhandled exception occurred at $0040BC40 :
EInOutError : File not open
  $0040BC40
  $00401506

A l'aide! (et merci d'avance )

[Dr.Who]

C'est trés bien, bon boulot, mais quand on utilise FreePascal on n'est plus obligé de faire du code à la Turbo Pascal.
POO et esprit RAD.

La structure CSV de ton fichier est pratique pour mettre en place un truc simple :

3 choses sont utiles ici :
2 petites et ma petite fonction GetStrPart.
le tout basé sur Class, TList et TStringList.

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
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
unit uStudents;
 
interface
 
uses Windows, SysUtils, Classes;
 
type
  TStudent = class
  private
    fName: string;
    fSurname: string;
    fNote: single;
    procedure SetText(const Value: string);
    procedure SetNoteStr(const Value: string);
  protected
    function GetText: string; virtual;
    function GetNoteStr: string; virtual;
  public
    property Surname : string read fSurname    write fSurname;
    property Name    : string read fName       write fName;
    property Note    : single read fNote       write fNote;
    property NoteStr : string read GetNoteStr  write SetNoteStr;
    property Text    : string read GetText     write SetText;
    constructor Create;
  end;
 
  TStudents = class
  private
    fElements : TList;
    function GetCount: integer;
    function GetElement(index: integer): TStudent;
    procedure SetElement(index: integer; const Value: TStudent);
  protected
  public
    property Items[index: integer]: TStudent read GetElement write SetElement;
    property Count: integer read GetCount;
    function Add: TStudent;
    procedure Clear;
    function ComputeMiddleNote: single;
    procedure Delete(aIndex: integer);
    procedure Exchange(aIndex1, aIndex2: integer);
    function FindName(aName: string): integer;
    function FindSurname(aSurname: string): integer;
    function FindPerson(aSurname, aName: string): integer;
    function FindNote(aNote: single): integer;
    function FindHighNote: integer;
    function FindLowNote: integer;
    procedure Insert(aElement: TStudent; aIndex: integer);
    procedure LoadFromFile(aFileName: string);
    procedure LoadFromStream(aStream: TStream);
    procedure LoadFromStrings(aStrings: TStrings);
    procedure SaveToFile(aFileName: string);
    procedure SaveToStream(aStream: TStream);
    procedure SaveToStrings(aStrings: TStrings);
    procedure SortByName(const ASC: boolean = true);
    procedure SortBySurname(const ASC: boolean = true);
    procedure SortByNote(const ASC: boolean = true);
    constructor Create;
    destructor Destroy;
  end;
 
implementation
 
uses StrUtils;
 
var
  defaultFS : TFormatSettings;
 
function CountChar(S: string; C: char): integer;
var N: integer;
begin
  result := 0;
  for N := 1 to Length(S) do
    if S[N] = C then
      inc(result);
end;
 
function GetStrPart(const Str, Delimiter: String; const WordIndex: cardinal = 1): String;
var I,P1,P2 : integer;
begin
  Result := '';
 
  if (posex(Delimiter,Str[1]) = 1) and (WordIndex <= 1) then
    exit;
 
  P1 := 1;
  for I := 1 to WordIndex-1 do
  begin
    P1 := posex(Delimiter, Str, P1);
    if P1 = 0 then
      exit
    else
      P1 := P1 + length(Delimiter);
  end;
 
  P2 := posex(Delimiter, Str, P1);
  if P2 = 0 then
    P2 := length(Str) + 1;
 
  Result := copy(Str, P1, P2 - P1);
end;
 
 
{ TElement }
 
constructor TStudent.Create;
begin
  fSurname := '';
  fName    := '';
  fNote    := 0.0;
end;
 
function TStudent.GetNoteStr: string;
begin
  result := format('%.3f',[fNote], DefaultFS);
end;
 
function TStudent.GetText: string;
begin
  result := fSurname+';'+fName+';'+GetNoteStr;
end;
 
procedure TStudent.SetNoteStr(const Value: string);
var V: single;
begin
  if TryStrToFloat(Value, V, DefaultFS) then
    fNote := V;
end;
 
procedure TStudent.SetText(const Value: string);
begin
  if CountChar(Value, ';') = 2 then
  begin
    fSurname := GetStrPart(Value, ';', 1);
    fName    := GetStrPart(Value, ';', 2);
    SetNoteStr(GetStrPart(Value, ';', 3));
  end;
end;
 
{ TElements }
 
function lscSortByNameASC(Item1, Item2: Pointer):integer;
begin
  Result := AnsiCompareStr(TStudent(Item1).fName, TStudent(Item2).fName);
end;
 
function lscSortByNameDESC(Item1, Item2: Pointer):integer;
begin
  Result := AnsiCompareStr(TStudent(Item2).fName, TStudent(Item1).fName);
end;
 
function lscSortBySurnameASC(Item1, Item2: Pointer):integer;
begin
  Result := AnsiCompareStr(TStudent(Item1).fSurname, TStudent(Item2).fSurname);
end;
 
function lscSortBySurnameDESC(Item1, Item2: Pointer):integer;
begin
  Result := AnsiCompareStr(TStudent(Item2).fSurname, TStudent(Item1).fSurname);
end;
 
function lscSortByNoteASC(Item1, Item2: Pointer):integer;
var E1, E2: TStudent;
begin
  E1 := TStudent(Item1);
  E2 := TStudent(Item2);
  if E1.fNote > E2.fNote then
    result := -1
  else
  if E1.fNote = E2.fNote then
    result := 0
  else
    result := 1;
end;
 
function lscSortByNoteDESC(Item1, Item2: Pointer):integer;
var E1, E2: TStudent;
begin
  E1 := TStudent(Item1);
  E2 := TStudent(Item2);
  if E1.fNote > E2.fNote then
    result := 1
  else
  if E1.fNote = E2.fNote then
    result := 0
  else
    result := -1;
end;
 
 
constructor TStudents.Create;
begin
  fElements := TList.Create;
end;
 
destructor TStudents.Destroy;
begin
  Clear;
  fElements.Free;
end;
 
function TStudents.Add: TStudent;
begin
  result := TStudent.Create;
  fElements.Add(result);
end;
 
procedure TStudents.Clear;
begin
  while fElements.Count > 0 do
  begin
    TStudent(fElements.Items[fElements.Count-1]).Free;
    fElements.Delete(fElements.Count-1);
  end;
end;
 
function TStudents.ComputeMiddleNote: single;
var N : integer;
    E : extended;
begin
  E := 0;
  for N := 0 to fElements.Count-1 do
    E := E + TStudent(fElements.Items[N]).fNote;
  result := E / fElements.Count;
end;
 
procedure TStudents.Delete(aIndex: integer);
begin
  TStudent(fElements.Items[aIndex]).Free;
  fElements.Delete(aIndex);
end;
 
procedure TStudents.Exchange(aIndex1, aIndex2: integer);
begin
  fElements.Exchange(aIndex1, aIndex2);
end;
 
function TStudents.FindHighNote: integer;
var N : integer;
    E : extended;
begin
  result := -1;
  if fElements.Count > 0 then
  begin
    E := TStudent(fElements.Items[0]).fNote;
    for N := 0 to fElements.Count-1 do
      if TStudent(fElements.Items[N]).fNote > E then
      begin
        E := TStudent(fElements.Items[N]).fNote;
        result := N;
      end;
  end;
end;
 
function TStudents.FindName(aName: string): integer;
var N : integer;
begin
  result := -1;
  for N := 0 to fElements.Count-1 do
    if TStudent(fElements.Items[N]).fName = aName then
    begin
      result := N;
      exit;
    end;
end;
 
function TStudents.FindSurname(aSurname: string): integer;
var N : integer;
begin
  result := -1;
  for N := 0 to fElements.Count-1 do
    if TStudent(fElements.Items[N]).fSurname = aSurname then
    begin
      result := N;
      exit;
    end;
end;
 
function TStudents.FindLowNote: integer;
var N : integer;
    E : extended;
begin
  result := -1;
  if fElements.Count > 0 then
  begin
    E := TStudent(fElements.Items[0]).fNote;
    for N := 1 to fElements.Count-1 do
      if TStudent(fElements.Items[N]).fNote < E then
      begin
        E := TStudent(fElements.Items[N]).fNote;
        result := N;
      end;
  end;
end;
 
function TStudents.FindNote(aNote: single): integer;
var N : integer;
begin
  result := -1;
  for N := 0 to fElements.Count-1 do
    if TStudent(fElements.Items[N]).fNote = aNote then
    begin
      result := N;
      exit;
    end;
end;
 
function TStudents.FindPerson(aSurname, aName: string): integer;
var N : integer;
begin
  result := -1;
  for N := 0 to fElements.Count-1 do
    if (TStudent(fElements.Items[N]).fSurname = aSurname) and
       (TStudent(fElements.Items[N]).fName    = aName)    then
    begin
      result := N;
      exit;
    end;
end;
 
function TStudents.GetCount: integer;
begin
  result := fElements.Count;
end;
 
function TStudents.GetElement(index: integer): TStudent;
begin
  result := fElements.Items[index];
end;
 
procedure TStudents.Insert(aElement: TStudent; aIndex: integer);
begin
  fElements.Insert(aIndex, aElement);
end;
 
procedure TStudents.LoadFromFile(aFileName: string);
var SL: TStringList;
begin
  SL := TStringList.Create;
  try
    SL.LoadFromFile(aFileName);
    LoadFromStrings(SL);
  finally
    SL.Free;
  end;
end;
 
procedure TStudents.LoadFromStream(aStream: TStream);
var SL: TStringList;
begin
  SL := TStringList.Create;
  try
    SL.LoadFromStream(aStream);
    LoadFromStrings(SL);
  finally
    SL.Free;
  end;
end;
 
procedure TStudents.LoadFromStrings(aStrings: TStrings);
var N: integer;
    E: TStudent;
begin
  if aStrings.Count > 0 then
  begin
    Clear;
    for N := 0 to aStrings.Count-1 do
      if (aStrings[N] <> emptyStr) and (CountChar(aStrings[N], ';') = 2) then
      begin
        E := Self.Add;
        E.SetText(aStrings[N]);
      end;
  end;
end;
 
procedure TStudents.SaveToFile(aFileName: string);
var SL: TStringList;
begin
  SL := TStringList.Create;
  try
    SaveToStrings(SL);
    SL.SaveToFile(aFileName);
  finally
    SL.Free;
  end;
end;
 
procedure TStudents.SaveToStream(aStream: TStream);
var SL: TStringList;
begin
  SL := TStringList.Create;
  try
    SaveToStrings(SL);
    SL.SaveToStream(aStream);
  finally
    SL.Free;
  end;
end;
 
procedure TStudents.SaveToStrings(aStrings: TStrings);
var N: integer;
begin
  aStrings.BeginUpdate;
  try
    aStrings.Clear;
    for N := 0 to Self.Count-1 do
     aStrings.Add(TStudent(fElements.Items[N]).GetText);
  finally
    aStrings.EndUpdate;
  end;
end;
 
procedure TStudents.SetElement(index: integer; const Value: TStudent);
begin
  TStudent(fElements.Items[index]).Text := Value.Text;
end;
 
procedure TStudents.SortByName(const ASC: boolean);
begin
  if ASC then
    fElements.Sort(lscSortByNameASC)
  else
    fElements.Sort(lscSortByNameDESC);
end;
 
procedure TStudents.SortByNote(const ASC: boolean);
begin
  if ASC then
    fElements.Sort(lscSortByNoteASC)
  else
    fElements.Sort(lscSortByNoteDESC);
end;
 
procedure TStudents.SortBySurname(const ASC: boolean);
begin
  if ASC then
    fElements.Sort(lscSortBySurnameASC)
  else
    fElements.Sort(lscSortBySurnameDESC);
end;
 
initialization
  SysUtils.GetLocaleFormatSettings(GetThreadLocale, defaultFS);
  defaultFS.DecimalSeparator := '.';
 
end.

j'avoue, je me suis emporté ... j'avais du temps.

[Pacorabanix]

merci beaucoup pour cet exemple !

Je vais surtout retenir la manière de gérer les string, car en effet tu t'es un peu emporté : dans mon cours je dois recréer la structure de liste, donc la fonction add() en particulier. C'est ça que je n'arrive apparemment pas à faire.
[edit : ou bien l'utilisation des fichiers avec les commandes de base...]

Et en plus je ne peux pas utiliser la programmation objet (c'est un cours pour 1ère année sur les structures de données), malgré le fait que je trouve ça bien plus clair et intuitif...

en fait je n'aurai pas du tagger cette discussion en "free-pascal" je pense, car ça n'a pas grand chose à voir avec le compilateur (d'ailleurs en cours ils nous demandent d'utiliser eclipse pour ça, ça me gavait d'installer un truc lourd alors j'ai pris free pascal)

[Dr.Who]

ah ok, je n'avais pas vus que c'etait suite à un cours.

garde quand même l'exemple, il reste valide et pourrait te servir plus tard.
ou le soumettre à ta classe pour montrer comment on réalise l'exercice avec la POO et les classes existantes en FPC/Delphi et comment tout cela facilite la vie et donne une meilleure consistance au programme.

je regarderais ce soir ce qui ne vas pas dans ton code et ce qui peut être améliorer.

[Pacorabanix]

problème résolu !

L'erreur était dans ma fonction "creerPatineur" qui transforme une chaine de caractère en structure "TPatineur" .

A un moment j'utilisais une variable intermédiaire de type pChar, ("chaine") et j'ai oublié de l'initialiser avant de l'utilser, avec un strAlloc ...

Horribles erreurs de pointeurs qui ne donnent jamais de bonne piste sur où elles sont !

merci quand même Dr et à +.