Discussion :

[Opera140]

Salut !

Je cherche à lire un fichier .txt et a stocker ses informations dans un tableaux de chaines pour les réutiliser plus tard.
Pour tester si le programme lit bien mon fichier, je veux retranscrire le contenu dans un autre fichier .txt.
J'ai donc écrit ceci :

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
 
var
Ligne : string;
Liste, Liste2 :Textfile;
TListe : array of string;
i : Integer;
 
.
.
.
 
AssignFile(Liste,'C:\MonPath\Liste.txt');
Reset(Liste);
AssignFile(Liste2,'C:\MonPath\Liste2.txt');
Rewrite(Liste2);
i:= 0;
while not EOF(Liste) do
  begin
    Readln(Liste, Ligne);
    TListe[i] := Ligne;
    Writeln(Liste2, TListe[i]);
     i := i+1;
  end;
.
.
.

Et donc ça ne marche pas.
J'ai essayer en créant le fichier avant et en utilisant Append() au lieu de Rewrite(), mais l'effet est le même.

Qu'est ce qui cloche ?

[Okaryn]

Tu ne redimensionnes pas ton tableau TListe, il faut que tu fasses un SetLength(TListe, i+1) avant d'utiliser la ligne TListe[i] := Ligne;

Autre chose, utilises plutôt inc(i) que i := i+1 (plus rapide)

[Opera140]

J'ai une ligne SetLength(TListe, 100);
Sachant que ma liste ne contiendra jamais autant d'entrées.
Merci pour le inc(i), je ne connaissais pas cette commande en Delphi

[Okaryn]

Ah oui, un truc tout bête, as-tu bien ajouté à la fin de ton code :

Code :

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

1
2
closefile(Liste);
closefile(liste2);

Sinon, il n'y a pas d'écriture dans liste2, juste sa création...

[anapurna]

salut

un autre conseil utilise les Tfilestream c'est mieux
plus facile a manipuler

@+ Phil

[Okaryn]

un autre conseil utilise les Tfilestream c'est mieux
plus facile a manipuler

Pour lire des lignes de texte, je trouve que l'utilisation des streams est beaucoup plus lourd qu'un simple TextFile qui n'a besoin que d'un ReadLn et WriteLn pour lire et écrire une ligne d'un coup.

Mais bon, je ne connais pas à fond les streams et je pense qu'il y a toujours besoin d'un buffer, donc nécessité de tester la longueur lue à chaque fois, etc...

[philnext]

Je pense que le plus simple c'est de passer par les TStringList non ?
pour lire un fichier, si par exemple on a une TStringList tsLines :

Code :

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

1
2
3
 
  tsLines.LoadFromFile('c:\fichier.txt');         //je lis mon fichier 
  tsLines.SaveToFile('c:\FichierDeTest.txt');  //je l'écris

[Okaryn]

Bien vu en effet ! Y'a pas plus simple lol

[droggo]

Hi,

Autre chose, utilises plutôt inc(i) que i := i+1 (plus rapide)

D'où te vient cette certitude ?

D'un a priori, pas d'une mesure, car en allant voir de plus près, le code généré est le même.

Quoi qu'il en soit, pour un programme lisant et écrivant des lignes de texte dans des fichiers, c'est absolument négligeable.

[Okaryn]

C'est sur que cela est négligeable, mais c'est une bonne habitude à prendre.

Cela vient d'une mesure, inc(I) est environ 50% plus rapide : il suffit de faire un test comparatif sur une boucle.

[rv26t]

Bonjour,

L'aide de Delphi l'indique.

Inc(X) équivaut à l'instruction X := X +1 et Inc(X, N) correspond à l'instruction X := X + N. En revanche, Inc génère un code optimisé, particulièrement utile dans les boucles à exécution intensive.

A+, Hervé.

[droggo]

Hi,

C'est sur que cela est négligeable, mais c'est une bonne habitude à prendre.

Cela vient d'une mesure, inc(I) est environ 50% plus rapide : il suffit de faire un test comparatif sur une boucle.

Mois j'ai le même temps d'exécution, aux fluctuations près, dues à l'utilisation du cpu par les autres programmes.

La mesure est faite avec des boucles assez longues pour que les temps soient significatifs. Ces temps sont mesurés avec les valeurs renvoyées par QueryPerformanceCounter.

Et comme je l'ai déjà dit, le code généré est le même, avec ma version Delphi en tout cas, et bien entendu en tenant compte des options de compilation.

[Okaryn]

Voici ma procédure de test avec Turbo Delphi Win32 (2006) :

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
procedure TForm1.Button1Click(Sender: TObject);
var
  I : integer;
  dStart, dEnd :Int64;
begin
  I := 0;
  QueryPerformanceCounter(dStart);
  While I < 100000000 do
    inc(I);
  QueryPerformanceCounter(dEnd);
  Edit1.Text := IntToSTr(dend-dStart);
  I := 0;
  QueryPerformanceCounter(dStart);
  While I < 100000000 do
    I := I + 1;
  QueryPerformanceCounter(dEnd);
  Edit2.Text := IntToSTr(dend-dStart);
end;

Et j'obtiens les valeurs suivantes (peut d'écarts sur une 20aines de tests) :
Inc() = 326682
I+1 = 505300

Pour les options de compilation, je n'ai pas changé le paramétrage par défaut.

[droggo]

Ho,

Ca à l'air convaincant, j'ai effectivement des affichages de l'ordre de grandeur que tu cites.

SAUF que, je confirme, le code généré est le même:

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
...
tes_console.dpr.14: While I < 100000000 do
00409159 81FB00E1F505     cmp ebx,$05f5e100
0040915F 7D09             jnl $0040916a
tes_console.dpr.15: inc(I);
00409161 43               inc ebx
tes_console.dpr.14: While I < 100000000 do
00409162 81FB00E1F505     cmp ebx,$05f5e100
00409168 7CF7             jl $00409161
 
...
 
tes_console.dpr.20: While I < 100000000 do
004091A4 81FB00E1F505     cmp ebx,$05f5e100
004091AA 7D09             jnl $004091b5
tes_console.dpr.21: I := I + 1;
004091AC 43               inc ebx
tes_console.dpr.20: While I < 100000000 do
004091AD 81FB00E1F505     cmp ebx,$05f5e100
004091B3 7CF7             jl $004091ac

C'est donc bizarre.

Allons voir plus loin :

En fait, si tu fais le test en inversant les 2 boucles, c'est à dire celle qui teste l'addition avant celle qui teste inc, tu trouveras un résultat opposé.

Cela dépend donc du moment où on appelle la boucle, par rapport au démarrage du calcul.
J'avoue ne pas comprendre pourquoi.

et si tu mets par exemple

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
  I := 0;
  QueryPerformanceCounter(dStart);
  While I < 100000000 do
    inc(I);
  QueryPerformanceCounter(dEnd);
  d1 := dend-dStart;
 
  I := 0;
  QueryPerformanceCounter(dStart);
  While I < 100000000 do
    I := I + 1;
  QueryPerformanceCounter(dEnd);
  d2 := dend-dStart;
 
  I := 0;
  QueryPerformanceCounter(dStart);
  While I < 100000000 do
    inc(I);
  QueryPerformanceCounter(dEnd);
  d1 := dend-dStart;

tu trouveras que les temps sont identiques, aux fluctuations près

Joli, non ?

[philnext]

Je viens mettre mon grain de sel dans ce post qui dérive méchamment...J'avoue que je n'avais jamais été convaincu par l'idée que le compilateur traite différemment i:=i+i et inc(i).
Bon ça n'a rien fait avancer...

[Okaryn]

En inversant, j'obtiens toujours le même écart !

Comment fais-tu pour voir le code généré, que je regarde également ?

[droggo]

Hi,

En inversant, j'obtiens toujours le même écart !

Comment fais-tu pour voir le code généré, que je regarde également ?

Tu mets un point d'arrêt, par exemple sur le 1er appel à QueryPerformanceCounter,
et tu affiches la fenêtre de debugage CPU, et tu regardes le code (c'est facile, car Delphi t'affiche d'abord la ligne du code source, suivie par le code généré.

[philnext]

(ça dérive de plus en plus)
Pour voir l'asm ce que je fais :
*Je met un point d'arret.
*quand le programme s'y arrête je fais clic droit/déboguer/Voir la CPU.
Y'a surement plus simple mais bon...

[user 56gt8]

Tout à fait daccord :Inc simplifie la synatxe du code mais est probablement compilé de la même manière que var:= var+incrément value.

[user 56gt8]

Y'a surement plus simple mais bon...

Ouais , avec IDA tu compares un programme test qui utilise d'une part la fonction inc et d'autre part un 'inc manuel'
si le code en langage assembleur est le même dans les deux cas c'est que inc c'est juste une aide syntaxique.