Lire un fichier.txt et retranscrire les informations dans un autre

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:

---

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 ?

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)

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 ;)

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

Code:

---

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

---

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

salut

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

@+ Phil

Citation:

---

Envoyé par anapurna

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...

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:

---

1 2 3

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

---

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

Hi,

Citation:

---

Envoyé par Okaryn

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.

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.

Bonjour,

L'aide de Delphi l'indique.

Citation:

---

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é.

Hi,

Citation:

---

Envoyé par 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.

---

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.

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

Code:

---

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.

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:

---

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:

---

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 :lol:

Joli, non ?

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...

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

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

Hi,

Citation:

---

Envoyé par Okaryn

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é.

(ç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...

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.

Citation:

---

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.
:lol: