votre avis sur une fonction qui copie un fichier dans un buffer

Version imprimable

Bonjour

Voila je suis apres m' entrainer un peu, donc j ai fait un programme qui prend un fichier en argument , puis (dans la fonction ci-dessous) il recopie tout le fichier dans un buffer pour ensuite l afficher, donc pour etre sur de pas avoir de probleme, je realloue le buffer tous le a chaque fois , mais je voudrais savoir ce que vous en pensez, si vous voyez des erreurs ou si il y a mieux et plus simple enfin bref votre avis quoi, pour l instant ca marche tres bien mais j ai quand meme des doute. voila le fichier en question :
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> #include "header.h" #define BUF_SIZE 1024 char *lire_fichier(FILE* fd, char *buffer) { int taille = BUF_SIZE; buffer = malloc(sizeof(char) * BUF_SIZE); if(!buffer) { erreur("Allocation de la memoire echoue\n"); exit(EXIT_FAILURE); } int c, i = 0; while((c = fgetc(fd)) && (c != EOF)) { if(c == '\n') { ligne++; } if(caractere >= taille) { buffer = realloc(buffer, taille*2); taille *= 2; } buffer[i++] = c; caractere++; } buffer[i++] = '\0'; return buffer; }
Merrci a vous.

Citation:

Envoyé par julio.t

je voudrais savoir ce que vous en pensez, si vous voyez des erreurs

Mon compilateur en voit...
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 -------------- Build: Debug in hello --------------- Compiling: main.c C:\dev\hello\main.c:3:20: header.h: No such file or directory C:\dev\hello\main.c: In function `lire_fichier': C:\dev\hello\main.c:15: warning: implicit declaration of function `erreur' C:\dev\hello\main.c:25: error: `ligne' undeclared (first use in this function) C:\dev\hello\main.c:25: error: (Each undeclared identifier is reported only once C:\dev\hello\main.c:25: error: for each function it appears in.) C:\dev\hello\main.c:27: error: `caractere' undeclared (first use in this function) Process terminated with status 1 (0 minutes, 0 seconds) 5 errors, 1 warnings
Le paramètre 'buffer' est inutile. une variable locale suffit.

'ligne', 'caractere' ne sont pas définis. Poste un code compilable. On ne peut pas deviner ce que tu as fais.

Eviter ce genre de code obscur...

Code:

buffer[i++] = c;

préférer
Code:

1 2 3 buffer[i] = c; i++;
qui est plus clair pour tout le monde.

La fonction devrait gérer elle-même l'ouverture/fermeture du fichier. C'est beaucoup plus simple :

Code:

char *lire_fichier (char const *fname)

J'ai mis une petite taille

Code:

int taille = 8;

pour solliciter le realloc(). Explosion !

ligne (que j'aurais appelé cpt_lignes) ne sert à rien.
caractere (que j'aurais appelé cpt_caracteres) ne sert à rien. i fait le boulot...

Code:

while ((c = fgetc (fp)) && (c != EOF))

Pas clair. Tu penses trouver un 0 dans un fichier texte ?

Je supose que tu veux

Code:

while ((c = fgetc (fp)) != EOF)

Ceci fonctionne :
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 45 46 47 48 49 50 51 52 53 54 55 56 57 #include <stdio.h> #include <stdlib.h> char *lire_fichier (char const *fname) { char *buffer = NULL; FILE *fp = fopen (fname, "r"); if (fp != NULL) { int taille = 2; buffer = malloc (taille); if (buffer != NULL) { int c, i = 0; while ((c = fgetc (fp))!= EOF) { if (i == taille - 1) { buffer = realloc (buffer, taille * 2); taille *= 2; } buffer[i] = c; i++; } buffer[i] = '\0'; } } else { perror (fname); } return buffer; } void test (char const *fname) { printf ("lecture de '%s'\n", fname); char *s = lire_fichier (fname); if (s != NULL) { printf ("'%s'\n", s); free (s); } } int main (void) { test (""); test ("../hello/dico.txt"); return 0; }

oupsss voila.

main.c

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "header.h"
 
extern int ligne;
extern int caractere;
 
int main(int argc, char **argv)
{
	if(argc != 2)
	{
		usage(argv[0]);
	}
 
	char *buf;
 
	FILE* fd;
 
	if((fd = fopen(argv[1], "r")) == NULL)
	{
		erreur("Impossible d' ouvrir le fichier en ecriture");
	}
 
	printf("%s", lire_fichier(fd,buf));
	printf("nombre de ligne :%d \t nombre de caracteres: %d\n\n", ligne, caractere);
 
 
	fclose(fd);
	return EXIT_SUCCESS;
}

lire_fichier.c :

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>
#include "header.h"
#define BUF_SIZE 1024
 
 
int caractere = 0, ligne = 0;
 
char *lire_fichier(FILE* fd, char *buffer)
{
 
	int taille = BUF_SIZE;
 
	buffer = malloc(sizeof(char) * BUF_SIZE);
 
	if(!buffer)
	{
		erreur("Allocation de la memoire echoue\n");
		exit(EXIT_SUCCESS);
	}
 
	int c, i = 0;	
 
	while((c = fgetc(fd)) && (c != EOF))
	{
			if(c == '\n')
			{
				ligne++;
			}
			if(caractere >= taille)
			{
				buffer = realloc(buffer, taille*2);
				taille *= 2;
			}
 
			buffer[i++] = c;	
 
			caractere++;		
	}
 
	buffer[i++] = '\0';
 
	return buffer;
}

header.h

Code:

1
2
3
4
5
6
7
8
9
#ifndef HEADER_H
#define HEADER_H
 
void usage(char *prog_name);
void erreur(char *chaine);
 
char *lire_fichier(FILE* fd, char *buffer);
 
#endif

fonction.c

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
#include <stdlib.h>
 
 
void usage(char *prog_name)
{
	fprintf(stderr ,"Usage : %s <fichier> \n", prog_name);
	exit(EXIT_FAILURE);
}
 
void erreur(char *chaine)
{
	fprintf(stderr, "%s", chaine);
	exit(EXIT_FAILURE);
}

makefile:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
CFLAGS= -g -W -Wall 
CC=gcc
 
essai: main.o fonction.o lire_fichier.o
	$(CC) -o $@ $^
 
main.o: main.c
	$(CC) -c $(CFLAGS) $<
 
fonction.o: fonction.c
	$(CC) -c $(CFLAGS) $<
 
lire_fichier.o: lire_fichier.c
	$(CC) -c $(CFLAGS) $<
 
clean: 
	rm -f *.o
	rm -f essai

Voila le code complet, j' avais effacer certain truc pour éclaircir ma fonction .

31/08/2008, 14h28
Emmanuel Delahaye
Citation:
Envoyé par julio.t

Code:

1 2 3 extern int ligne; extern int caractere;
Pas besoin de ces globales[1]. J'ai donné une correction. Si tu veux que la fonction compte les caractères et les lignes, il faut ajouter le contexte adéquate : par exemple, un pointeur sur
Code:

1 2 3 4 5 6 struct compteurs { int caracteres; int lignes; };
-------------------
[1] de plus, mauvais usage. Comme pour les fonctions, les déclarations se mettent dans des headers...

http://emmanuel-delahaye.developpez....s.htm#globales
31/08/2008, 15h28
julio.t

ok merci bien .
31/08/2008, 15h37
wiztricks
Ok ca marche mais... pour recopier le contenu du fichier dans un buffer mémoire pourquoi ne pas:
1. allouer un buffer à la taille du fichier à lire? (fstats)
2. lire son contenu d'un seul coup (read/fread)?
- W
31/08/2008, 15h52
julio.t

Citation:

allouer un buffer à la taille du fichier à lire? (fstats)

Je pensais justement que la struct stat pourrais me servir mais je ne savais pas comment . merci tu ma éclairé la d' un coup .

Donc je vais essayer de le refaire pour qu il fasse a peu pres la meme chose :

Je map le fichier (mmap et donc j aurais besoin de la struct stat) en memoire

et je lis normalement avec modification possible .

Merci de ton intervention et merci a Emmanuel Delahaye aussi qui ma bien eclairer.

je vous donne des nouvelles quand je fini.
02/09/2008, 13h28
oniric

utiliser un buffer de taille 'n', permettrai d'eviter de faire des appels systemes (les plus couteux) pour chaque caractere, et serai donc bcp plus rapide. (read/fread).

tu peux soit utiliser fstat, mais imaginons que tu veuilles lire la bible en entiere, tu as de forte chance de faire exploser la memoire si tu alloues l'espace entier.

Enfin ca depend de ce que tu veux faire apres. Imaginons que tu veuilles faire un traitement particulier sur ce fichier apres, il serait plus judicieux de recoder une fonction du type getln(int fd) (fonction qui bufferise, et qui renvoie la prochaine ligne ou NULL sinon).

c99eusement
02/09/2008, 13h44
droggo

Jue,

Citation:

Envoyé par oniric

utiliser un buffer de taille 'n', permettrai d'eviter de faire des appels systemes (les plus couteux) pour chaque caractere, et serai donc bcp plus rapide. (read/fread).

tu peux soit utiliser fstat, mais imaginons que tu veuilles lire la bible en entiere, tu as de forte chance de faire exploser la memoire si tu alloues l'espace entier.

Enfin ca depend de ce que tu veux faire apres. Imaginons que tu veuilles faire un traitement particulier sur ce fichier apres, il serait plus judicieux de recoder une fonction du type getln(int fd) (fonction qui bufferise, et qui renvoie la prochaine ligne ou NULL sinon).

c99eusement

Il n'est précisé nulle part qu'on travaille avec un fichier texte. :)
02/09/2008, 13h52
oniric

non mais je vois qu'il check les '\n' donc si ce n'est pas un fichier texte qu'est ce donc ? :P un fichier binaire separer par des '\n' ? pas grave, ca marchera quand meme du coup :D

trolleusement