Fichier limité à 4Ko

Version imprimable

Bonjour à tous,

J'ai créé à l'aide de code::blocks un programme qui copie les lignes d'un fichier en y ajoutant quelques caractère "au bout" dans un autre fichier. Le problème est le suivant : l'écriture s'arrête inexplicablement lorsque le fichier copié dépasse 4Ko. Alors que la fonction qui copie parcours bien tout le fichier.

Le code :

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
#include <stdio.h>
#include <stdlib.h>
 
int main()
{
    FILE* fichier1 = NULL;
    FILE* fichier2 = NULL;
    fichier1= fopen("b3.txt","r");
    fichier2= fopen("b4.txt","w+");
    char ajout[] = "</br>\n";
    char chaine[10000]="";
    long i=0;
 
    if(fichier1==NULL)
        {
        printf("fichier non trouve");
        }
    else{
 
         do
         {
          do{i++;}while(fgetc(fichier1)!='\n');
 
fseek(fichier1,-i-1,SEEK_CUR);
fgets(chaine,i,fichier1);
 
fputs(chaine,fichier2);
fprintf(fichier2,"</br>\n");
 
 
printf("%d  %d\n",ftell(fichier1),ftell(fichier2));
 
i=0;
         }while(fgetc(fichier1)!='\0');
 
 
   fclose(fichier1);
   fclose(fichier2);
    }
 
 
    return 0;
}

Merci d'avance ;)

Salut
J'ai recopié tel quel ton code chez-moi et il m'a parfaitement recopié un fichier de 188ko. Toutefois le programme ne s'est pas arrêté et j'ai du l'interrompre manuellement

Concernant ton code: outre qu'il est indenté comme un porc, je ne pige pas:
cette première boucle pour récupérer un '\n' et surtout ce fseek(..., -i-1) !!! Si tu as envie de revenir au début, pourquoi ne pas utiliser un fseek(fichier, 0, SEEK_SET) ???
Cette recherche de '\0' dans le fichier. Ce n'est pas que ce soit impossible de placer un '\0' dans un fichier texte mais déjà ce n'est plus un vrai fichier texte et surtout on a plutôt l'habitude de voir le '\0' comme flag de fin de chaine et non flag de fin de fichier...
ce "i=0" en fin de boucle alors que i sera utilisé comme nombre d'octets à lire dans le fgets() suivant...

Sinon voici ton code réindenté proprement. C'est quand-même un minimum quand on demande aux autres de lire ses oeuvres qu'elles soient un peu lisibles...
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 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 #include <stdio.h> #include <stdlib.h> int main() { FILE* fichier1 = NULL; FILE* fichier2 = NULL; fichier1= fopen("b3.pdf","r"); fichier2= fopen("b4.pdf","w+"); char ajout[] = "\n"; char chaine[10000]=""; long i=0; if(fichier1==NULL) { printf("fichier non trouve"); // Jamais tu fermes fichier 2 ??? } else { do { do { i++; } while(fgetc(fichier1)!='\n'); fseek(fichier1,-i-1,SEEK_CUR); fgets(chaine,i,fichier1); fputs(chaine,fichier2); fprintf(fichier2,"\n"); // Ces deux lignes en une seule: fprintf(fichier2,"%s\n", chaine); printf("%d %d\n",ftell(fichier1),ftell(fichier2)); i=0; } while(fgetc(fichier1)!='\0'); fclose(fichier1); fclose(fichier2); } return 0; }

29/01/2013, 02h39
lappin

Merci d'avoir jeté et excuse-moi pour avoir oublié d'indenté.
Si cela peut éclairer, il s'agite de recopier un fichier, non généré par moi, de la forme :
ligne1 \n
ligne2 \n
ligne3 \n
...
Et d'y ajouter à la fin de chaque ligne. i représente en fait la longueur de la ligne à chaque étape. Le déplacement de -i-1 a pour but de revenir à la fin de la ligne une fois que j'en connais la longueur (je n'utilise pas la fonction strlen car il n'y a pas le caractère de fin de chaine à chaque ligne).
Si je recherche '\0' dans le fichier et que je termine par ce même caractère c'est parce que dans mon fichier source je me suis aperçut qu'il s'agissait du dernier caractère du fichier.
Si je remet i à 0, c'est pour réinitialiser la longueur de la linge.

Le code produit le résultat voulu, seulement il arrête d'écrire dans le fichier b4 dès que celui-ci atteint 4.135 octets. Alors qu'il m'affiche en console que le pointeur se déplace tout le long des lignes du fichier.

Citation:

Envoyé par lappin

Merci d'avoir jeté et excuse-moi pour avoir oublié d'indenté.
Si cela peut éclairer, il s'agite de recopier un fichier, non généré par moi, de la forme :
ligne1 \n
ligne2 \n
ligne3 \n
...
Et d'y ajouter à la fin de chaque ligne. i représente en fait la longueur de la ligne à chaque étape. Le déplacement de -i-1 a pour but de revenir à la fin de la ligne une fois que j'en connais la longueur (je n'utilise pas la fonction strlen car il n'y a pas le caractère de fin de chaine à chaque ligne).

Ok ben alors ça sera plus simple de cette façon
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 char *c; char ligne[1000]; FILE *fichier1; FILE *fichier2; fichier1=fopen(...); fichier2=fopen(...); while (fgets(ligne, 1000, fichier1) != EOF) { // Suppression '\n' if ((c=strchr(ligne, '\n') != NULL) *c='\0'; // Ecriture nouvelle ligne (en y incluant le '\n' supprimé) fprintf(fichier2, "%s \n", ligne); } // Fini fclose(fichier1); fclose(fichier2);
Donc le principe est là: tu lis une ligne, tu arranges un peu cette ligne et tu la réécris. Et bien que le fgets(), comme toute fonction génératrice de string, s'occupe de mettre lui-même le '\0', nul besoin d'utiliser strlen(). Seul danger: qu'une des lignes de ton fichier soit plus longue que 999 octets. Dans ce cas, tu en récupèreras 2 dans l'autre fichier...

Citation:

Envoyé par lappin

Si je recherche '\0' dans le fichier et que je termine par ce même caractère c'est parce que dans mon fichier source je me suis aperçut qu'il s'agissait du dernier caractère du fichier.

Hum, là j'ai un très gros doute. Faudra que tu nous montres de quelle façon tu as fait cette recherche/découverte...

29/01/2013, 11h33
diogene

@lappin
Ta méthode n'est pas bonne :
- La fin de fichier n'est pas détectée de cette façon : fgetc() ne renvoie pas '\0' dans ce cas mais EOF
- Le comportement de fseek() utilisé de cette façon pour des fichiers texte est dépendante de l'implémentation.

Utilise plutôt la méthode préconisée par Sve@r

Merci pour les conseils sur le code, le recopiage fonctionne et la forme obtenue est bonne cependant, il reste quelques problèmes :

La ligne :

Code:

*c='\0';

, fait planter le programme. Si j'ai bien compris il s'agit de placer le caractère de fin de chaine pour la raccourcir (supprimer le saut de ligne). Comme le saut de ligne ne me dérange pas j'ai alors supprimé cette ligne. La chaine de caractères contient alors le '\n' mais s'arrête juste après.
La boucle ne s'arrête pas :
Le programme recopie la dernière ligne à l'infini.

Citation:

Citation:

Si je recherche '\0' dans le fichier et que je termine par ce même caractère c'est parce que dans mon fichier source je me suis aperçut qu'il s'agissait du dernier caractère du fichier.

Hum, là j'ai un très gros doute. Faudra que tu nous montres de quelle façon tu as fait cette recherche/découverte...

Je me suis juste empiriquement aperçut qu'avec cette condition la boucle "while" stoppait au bon moment ( à la dernière ligne du fichier).

Pour info voici mon code :
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 27 char *c; char ligne[1000]; FILE *fichier1; FILE *fichier2; fichier1=fopen("b3.txt","r+"); fichier2=fopen("b4.txt","w+"); while (fgets(ligne, 1000, fichier1) != EOF) { printf("%s ",ligne); if (c=strchr(ligne, '\n') != NULL) { /* *c ='\0';*/ fprintf(fichier2, "%s\n", ligne); } } fclose(fichier1); fclose(fichier2); return 0;
J'espère que l'indentation suffit, pratiquant la programmation en amateur je n'ai pas l'habitude que mon code sois lu.

Citation:

Envoyé par lappin

La ligne :

Code:

*c='\0';

, fait planter le programme. Si j'ai bien compris il s'agit de placer le caractère de fin de chaine pour la raccourcir (supprimer le saut de ligne). Comme le saut de ligne ne me dérange pas j'ai alors supprimé cette ligne. La chaine de caractères contient alors le '\n' mais s'arrête juste après.

C'est exact. strchr() cherche un caractère précis dans une string et te renvoie l'adresse de ce caractère (ou NULL s'il ne le trouve pas). En mettant un caractère '\0' à cette adresse, on raccourci effectivement la string (puisque toute fonction traitant la chaine s'arrêtera à ce '\0'). Donc effectivement ce petit bloc a pour but de virer le '\n' de la ligne.

Toutefois le plantage vient d'une erreur de ma part (erreur de parenthèses). Au lieu d'écrire if (c=strchr(ligne, '\n') != NULL) (ce qui se lit quand on fait attention "copier dans c le booléen issu de la comparaison) ; il faut écrire if ((c=strchr(ligne, '\n')) != NULL) (ce qui se lit "copier dans c la valeur retournée par strchr et vérifier en même temps si cette valeur n'est pas nulle) et là ça marchera (dans le premier cas, c ne contient pas l'adresse du caractère mais juste un booléen).
Citation:
Envoyé par lappin
Pour info voici mon code :
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 char *c; char ligne[1000]; FILE *fichier1; FILE *fichier2; fichier1=fopen("b3.txt","r+"); fichier2=fopen("b4.txt","w+"); while (fgets(ligne, 1000, fichier1) != EOF) { printf("%s ",ligne); if (c=strchr(ligne, '\n') != NULL) { /* *c ='\0';*/ fprintf(fichier2, "%s\n", ligne); } } fclose(fichier1); fclose(fichier2); return 0;
J'espère que l'indentation suffit, pratiquant la programmation en amateur je n'ai pas l'habitude que mon code sois lu.
Oui oui c'est bon. L'important est qu'on arrive à voir les blocs de travail.

PS: les modes "+" de tes fopen() n'ont pas de raison d'être (si tu n'écris pas dans le premier et que tu ne lis pas le second)

30/01/2013, 00h28
lappin

1 pièce(s) jointe(s)

Après toute cette aide le programme fonctionne mieux, cependant pour une raison qu'il m'échappe la boucle ne s'arrête pas et le fichier s'arrête d'écrire dans le fichier avant la fin (même erreur qu'au début).
Je ne sais pas ce qui peut-être utile, donc j'ai envoyé la totalité du projet codeblocks contenant le fichier de code et les fichier b3 et b4.
b4 a été généré par le programme que j'ai stoppé manuellement car il ne s'arrêtait pas. J'ai modifié le fichier source car il provient d'un ami et je n'ai pas envie de le rendre public, mais celui testé lui ai similaire et génère les même erreurs.

http://www.developpez.net/forums/att...1&d=1359501536

Citation:

PS: les modes "+" de tes fopen() n'ont pas de raison d'être (si tu n'écris pas dans le premier et que tu ne lis pas le second)

Oui je sais mais je les supprimerais plus tard, quand je commence de coder, je ne sais pas si je peut être amener à lire ou à écrire. Donc dans le doute je prévois au plus large.
30/01/2013, 05h34
Ngork
Si ton programme est sous linux alors inutile de lire la suite de mon message, mais si ton programme est sous Windows et que tes fichiers ne sont pas des vrais fichiers textes (de fait ils contiennent des \0 donc j'ai comme un doute), alors tu dois écrire un "rb" (lecture d'un fichier binaire) ou un "wb" (écriture d'un fichier binaire) dans tes fopen sinon, rien ne te garantit le résultat de la copie et notamment rien ne sera écrit dans le fichier de destination après que ton programme ait croisé un \0 dans le fichier source (signale la fin du texte) ! 8O
Code:

1 2 fichier1=fopen("b3.txt","rb"); fichier2=fopen("b4.txt","wb");

Citation:

Envoyé par lappin

Après toute cette aide le programme fonctionne mieux, cependant pour une raison qu'il m'échappe la boucle ne s'arrête pas et le fichier s'arrête d'écrire dans le fichier avant la fin (même erreur qu'au début).

Autre erreur de ma part: fgets() ne renvoie pas EOF quand le fichier est fini mais NULL. Bizarre qu'aucun des pros qui sont passé par là ne l'ai relevée (trop confiance dans mes posts probablement ce qui est flatteur mais aussi source de danger ;))

Donc ce code ci a été compilé, testé et a marché avec les fichiers de tes exemples sans souci
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 27 28 29 #include <stdio.h> #include <stdlib.h> #include <string.h> int main() { char *c; char ligne[1000]; FILE *fichier1; FILE *fichier2; fichier1=fopen("b3.txt","r"); fichier2=fopen("b4.txt","w"); while (fgets(ligne, 1000, fichier1) != NULL) { /* printf("%s ",ligne);*/ if ((c=strchr(ligne, '\n')) != NULL) *c ='\0'; fprintf(fichier2, "%s\n", ligne); } fclose(fichier1); fclose(fichier2); return 0; }
Attention, dans ton code tu avais inclut le fprintf() dans le if. Ca veut dire que la ligne est écrite que si elle contenait un '\n'. A la base ça ne pose pas de souci (toute ligne en contient un) sauf si une ligne est plus grande que 999 octets. Dans ce cas, tu obtiendras de l'autre coté seulement la fin de la ligne (le début ne contenant pas de '\n' n'étant pas écrit de l'autre coté).

PS: normalement, tu avais du avoir un warning à la compil quand tu comparais fgets() avec EOF et tu n'en as pas tenu compte. Ben ça c'est pas bien. Toujours regarder les warning car ils signifient "je n'ai pas bien saisi votre but donc peut-être que ce que je fais c'est pas bien" ce qui est souvent le cas. Donc réflexes:
quand j'utilise une fonction inconnue, je regarde dans la doc comment elle se comporte
quand je recopie les codes des fofos, je prends en compte le fait que le posteur ne soit pas à l'abri des erreurs surtout si le code ne se compile pas parfaitement

Citation:

Envoyé par lappin

...quand je commence de coder, je ne sais pas si je peut être amener à lire ou à écrire. Donc dans le doute je prévois au plus large.

Pas forcément une bonne chose. Prévoir plus large te supprime parfois certains garde fous qui auraient pu être utiles...

Citation:

Envoyé par Ngork

Si ton programme est sous linux alors inutile de lire la suite de mon message, mais si ton programme est sous Windows et que tes fichiers ne sont pas des vrais fichiers textes (de fait ils contiennent des \0 donc j'ai comme un doute), alors tu dois écrire un "rb" (lecture d'un fichier binaire) ou un "wb" (écriture d'un fichier binaire) dans tes fopen sinon, rien ne te garantit le résultat de la copie et notamment rien ne sera écrit dans le fichier de destination après que ton programme ait croisé un \0 dans le fichier source (signale la fin du texte) ! 8O

Bien pensé (+1). C'était utile d'y songer. Mais ce n'est pas le cas. Ses fichiers sont de vais fichiers texte donc ça va de ce coté. :ccool:

30/01/2013, 17h17
Médinoc

Au passage, je conseillerais aussi de ne rajouter le que si c!=NULL (même si en pratique une ligne de plus de 999 caractères est peu probable). Ainsi, si une ligne fait plus de 999 caractères, elle ne sera pas tronquée.
30/01/2013, 17h26
lappin

Merci, à tous le code fonctionne :ccool:

Code:

quand j'utilise une fonction inconnue, je regarde dans la doc comment elle se comporte

Oui, j'y penserai à l'avenir. Je suis plutôt curieux d'habitude, mais lorsque je code dans un but précis, j'ai tendance à zapper certaines étapes.

L'allusion à Linux est intéressante, car j'utilise les 2 OS sans trop connaitres les différences dans leur gestions des fichiers. Alors je me demande, y'a t'il des différences si on ouvre un fichier en binaire ? Doit-on seulement seulement faire attention à mettre \r\n ?

Je me pose encore une question :
Sinon je me demande ce qui fesait stopper l'écriture dans mon code initial alors que la boucle parcourait tout le fichier.

En tout cas encore merci ;)
30/01/2013, 18h32
Sve@r

Citation:

Envoyé par lappin

L'allusion à Linux est intéressante, car j'utilise les 2 OS sans trop connaitres les différences dans leur gestions des fichiers. Alors je me demande, y'a t'il des différences si on ouvre un fichier en binaire ? Doit-on seulement seulement faire attention à mettre \r\n ?

On en a parlé justement ces jours ci => http://www.developpez.net/forums/d13...e-apres-copie/
30/01/2013, 19h09
lappin

Ok, merci je met le sujet résolu. Mais je me demande toujours ce qui arrêtait l'écriture.

Et encore merci pour l'aide :ccool:

Citation:

Envoyé par lappin

Mais je me demande toujours ce qui arrêtait l'écriture.

Parce que ton code bloquait à un moment donné alors que l'écriture n'était pas finalisée.
Ce n'est pas parce que tu fais un fprintf/fputs/fputc que l'écriture se fait à ce moment là. Les IO sont bufferisées pour optimiser les accès disque et donc les écritures se font dans un buffer
Exemple
Code:

1 2 3 4 5 6 int main() { printf("Hello..."); sleep(10); printf("...world\n"); }
Tu compiles, tu exécutes et tu verras que ça commence par attendre 10sec avant d'afficher "Hello world" à l'écran. Parce que l'écriture réelle se fait quand le buffer est vidé et qu'il n'est vidé que dans certains cas particuliers
quand il rencontre '\n'
quand il est plein
quand le fichier est fermé
quand on demande explicitement un vidage via fflush()

Et donc si tu rajoutes un fflush(stdout) avant le sleep() là tu auras "Hello" puis 10 sec après "world".

Donc pour en revenir à ton problème, ton code part en torche dans une boucle infinie et n'écrit plus rien dans le buffer qui reste donc en mémoire et ne se vide pas dans le fichier qui reste donc à 4ko (pour toi car de mon coté, il est monté jusqu'à 12ko probablement parce que mon buffer est plus petit donc rempli/vidé plus rapidement)

Accessoirement j'ai trouvé l'erreur (les erreurs en fait) de ton premier code
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 27 28 29 30 31 32 33 #include <stdio.h> #include <stdlib.h> int main() { FILE* fichier1 = NULL; FILE* fichier2 = NULL; fichier1= fopen("b3.txt","r"); fichier2= fopen("b4.txt","w+"); char ajout[] = "\n"; char chaine[10000]=""; long i; do { i=0; do { i++; } while(fgetc(fichier1)!='\n'); fseek(fichier1,-i-1,SEEK_CUR); fgets(chaine,i+1,fichier1); fputs(chaine,fichier2); fprintf(fichier2,"\n"); printf("%d %d\n",ftell(fichier1),ftell(fichier2)); } while(fgetc(fichier1) != EOF); fclose(fichier1); fclose(fichier2); return 0; }
Outre le fait que tu cherchais un '\0' inexistant, tu ne récupérais pas la ligne entière avec ton fgets() vu que (encore une fois) tu ne t'étais pas renseigné sur cette fonction. Si tu l'avais fait, tu aurais vu que si on lui demande 10 octets elle n'en lit que 9 car garde le dernier pour y stocker le '\0' qu'elle doit impérativement mettre (vu qu'elle garantit une string au final).

Donc regarde ce qui se passe quand ça arrive en fin de fichier. Il ne reste que 10 octets à lire. Tu commence par chercher où se trouve le '\n' avec ton do...while. Ca te répond "10". Puis tu recules de 10 éléments pour te remettre à la même position (accessoirement tu aurais fait un ftell() pour la mémoriser avant ça aurait été bien plus sioux). Ensuite tu demandes 10 octets avec ton fgets() mais cette fonction n'en récupère que 9. Ensuite le while(fgetc()) lit le dernier caractère du fichier (un '\n') et ne renvoie donc pas EOF vu que la lecture a pu se faire. Tu remontes alors en haut du do et là tu refais un do...while pour chercher ensuite un autre '\n'. Mais il n'y en a plus vu que tu viens juste de lire le dernier caractère du fichier. Boucle infinie...

Ca démontre aussi qu'il est parfois dangereux de lire un même fichier plusieurs fois à différents moments du code...

Affaire résolue :bravo::roi:

02/02/2013, 01h47
lappin

Voilà qui répond à toutes mes questions, merci :ccool: