Lecture d'un fichier octet par octet

Version imprimable

08/06/2012, 11h05
Nico_stras

Lecture d'un fichier octet par octet

Bonjour,
Je souhaitrais savoir quel est le moyen le plus efficace pour lire un fichier octet par octet (pour calculer un checksum).

ce qui parait le simple, c'est :

- fopen()
- fread() de 1 octet jusqu'à EOF
- fclose()

Sachant que le fichier est sur une mémoire de masse, est ce que le fopen() va tout copier en RAM ?
Est ce que la fonction fread est une fonction "lente" ?
Est-il plus efficace de de lire tout le fichier d'un coup (quid de la récupération sa taille...) et de le placer dans un char* avant de manipuler cette variable ?

Merci d'avance pour vos avis.

PS : développement sur un OS type UNIX

Nicolas
08/06/2012, 12h09
Neckara

Tu peux déjà utiliser les fonctions open, read et close au lieu de fopen, fread et fclose pour être plus rapide.

Pour fopen, il ne me semble pas qu'il copie tout en RAM mais qu'il copie le(s) partie(s) du fichiers sur lequel tu travaille actuellement (à vérifier tout de même)

Tu peux en effet lire ton fichier d'un coup je pense que ce sera plus pratique et rapide. Dans ce cas là pour récupérer la taille de ton fichier, utilise struct stat de sys/stat.h
08/06/2012, 16h19
matafan

Au contraire, si tu fais des lectures octet par octet fopen/fread sera beaucoup plus rapide que open/read puisque les lectures sont bufferisées.

Effectivement fread charge le fichier par morceaux. On peut changer la taille du buffer avec setvbuf().

L'autre option, c'est de mapper le fichier en mémoire avec mmap(). C'est plus simple et potentiellement plus efficace si tu dois faire des accès aléatoires. Si tu lis le fichier séquentiellement, ça ne change pas grand chose.
08/06/2012, 16h24
phi1981

Citation:

Au contraire, si tu fais des lectures octet par octet fopen/fread sera beaucoup plus rapide que open/read puisque les lectures sont bufferisées

En effet, fopen cause une bufferisation du fichier, que open ne fait pas (du moins par défaut).
Mais une fois fopen appelée, lire le fichier octet par octet peut se faire simplement avec fgetc(), qui utilisera le buffer créé par fopen. C'est plus simple que d'utiliser fread.

Voici ce que j'ai pour le moment :
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 UINT16 CRC_File(const char* szPath) { FILE* fichier ; char c ; UINT8 j = 0 ; UINT16 usCRCWord = 0; UINT16 usPoly = 0x8408; UINT8 bParite=0 ; fichier = fopen(szPath,"r") ; if(0!=fichier) { while(feof(fichier)==0) { fread(&c,1,1,fichier) ; usCRCWord^=c; for(j=0;j<8;j++) { if(usCRCWord & 1) bParite=0; else bParite=1; usCRCWord>>=1; if(!bParite) usCRCWord^=usPoly; } } fclose(fichier) ; } return usCRCWord ; }
Donc si j'ai bien compris, mieux vaut utiliser une variable intermédiaire (const char*) et appeler une seule fois la fonction fread().

Dans ce cas, je suis obligé de passer par un malloc() pour créer mon buffer.

Correct ?

08/06/2012, 17h09
Nico_stras

Citation:

Envoyé par phi1981

Mais une fois fopen appelée, lire le fichier octet par octet peut se faire simplement avec fgetc(), qui utilisera le buffer créé par fopen. C'est plus simple que d'utiliser fread.

Pourquoi plus simple ?
fgetc() n'est pas à utiliser que pour de l'ascii ?
09/06/2012, 14h32
Taurre

Salut,

Citation:

Mais une fois fopen appelée, lire le fichier octet par octet peut se faire simplement avec fgetc(), qui utilisera le buffer créé par fopen. C'est plus simple que d'utiliser fread.

Juste pour dire, parce que la phrase est ambiguë, la fonction fread utilise également le tampon alloué par fopen. De manière générale, toute les fonctions standard de traitement de flux utilisent le tampon associé à un flux (lorsqu'il en a un).

Citation:

fgetc() n'est pas à utiliser que pour de l'ascii ?

Non, étant donné qu'un flux binaire n'est qu'une suite ordonnée de byte (char), il est tout à fait possible de lire chacun d'entre eux à l'aide de fgetc.

Sinon, pour répondre à la question, la bonne solution me semble d'ouvrir le fichier en mode binaire ("rb") et d'effectuer la lecture par bloc de taille BUFSIZ. Autrement dit, de remplir un tableau de unsigned char de taille BUFSIZ à l'aide de fread et de parcourir ensuite ce dernier caractère par caractère pour effectuer la somme.

Citation:

L'autre option, c'est de mapper le fichier en mémoire avec mmap(). C'est plus simple et potentiellement plus efficace si tu dois faire des accès aléatoires. Si tu lis le fichier séquentiellement, ça ne change pas grand chose.

Citation:

Tu peux en effet lire ton fichier d'un coup je pense que ce sera plus pratique et rapide. Dans ce cas là pour récupérer la taille de ton fichier, utilise struct stat de sys/stat.h

Je doute que ces deux solutions soient plus rapide qu'une lecture par bloc étant donné qu'elles impliquent une allocation dynamique potentiellement importante (voir irréalisable si le fichier est trop volumineux).
09/06/2012, 14h37
Obsidian

Hello,

Citation:

Envoyé par Nico_stras

Pourquoi plus simple ?
fgetc() n'est pas à utiliser que pour de l'ascii ?

Non. fgetc() va te renvoyer un unsigned char dans le sens C du terme, transtypé en INT pour pouvoir éventuellement te renvoyer EOF. C'est assurément ce qu'il y a de plus simple ici.
09/06/2012, 15h02
Nico_stras

Citation:

Envoyé par Taurre

Sinon, pour répondre à la question, la bonne solution me semble d'ouvrir le fichier en mode binaire ("rb") et d'effectuer la lecture par bloc de taille BUFSIZ. Autrement dit, de remplir un tableau de unsigned char de taille BUFSIZ à l'aide de fread et de parcourir ensuite ce dernier caractère par caractère pour effectuer la somme.

BUFSIZ est une constante définie dans un header ?

Comment implémenter cette lecture par bloc ?
Lire 1 bloc, le traiter, puis lire un autre bloc, plus le traiter ?

Aurais-tu un petit bout de pseudo-code?

En suivant la trame :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stddef.h>
#include <stdio.h>
....
#define BUFSIZE ....
unsigned char buf[BUFSIZE];
size_t n;
f = fopen(..., "rb");
if(f!=NULL)
{
  do
  {
    n = fread(buf,1,BUFSIZE,f);
    /* traiter les n premières valeurs du tableau buf */
   }while(n== BUFSIZE);
  if(feof(f)) printf("lecture terminée");
  else printf("erreur de lecture");
  fclose(f);
}

09/06/2012, 18h17
Nico_stras

quelle est la valeur de BUFSIZE ?
Si j'ai des fichiers pouvant atteindre 10 Mo ?
10/06/2012, 20h25
Taurre

Désolé pour cette réponse tardive.

Citation:

Envoyé par Nico_stras

BUFSIZ est une constante définie dans un header ?

Oui, elle est définie dans l'en-tête <stdio.h>, tu n'as donc pas à te préoccuper de sa valeur ;)

Je ne comprends pas ce code :

Citation:

Envoyé par diogene

Code:

1
2
3
4
5
6
7
8
9
10
11
 
...
  do
  {
    n = fread(buf,1,BUFSIZE,f);
    /* traiter les n premières valeurs du tableau buf */
   }while(n== BUFSIZE);
  if(feof(f)) 
     printf("lecture terminée");
  else 
     printf("erreur de lecture");

pourquoi

Code:

while(n== BUFSIZE);

?

Pourquoi unr erreur si on est pas à la fin du fichier ?

Code:

1
2
3
4
  if(feof(f)) 
     printf("lecture terminée");
  else 
     printf("erreur de lecture");

11/06/2012, 12h21
diogene

fread() renvoie le nombre d'éléments lus. On lui a demandé d'en lire BUFSIZE. Si il en a lu moins, c'est que - soit il a atteint la fin du fichier et il n'y avait plus rien à lire,- soit il y a eu une erreur de lecture sur le fichier. Les deux cas peuvent se distinguer par la fonction feof() (ou ferror()). Si on est sûr que le deuxième cas ne peut se produire, le test est inutile et on sort de la boucle sur la fin de fichier.
12/06/2012, 16h27
Nico_stras
Sachant que BUFSIZE est une constante

Code:

while(n== BUFSIZE);

que se passe-t-il si la taille du fichier est inférieure ? appels de fread inutilement ? erreurs ?
Code:

1 2 3 4 if(feof(f)) printf("lecture terminée"); else printf("erreur de lecture");
que se passe-t-il si la taille du fichier est supérieure ? Il faut reboucler ?

A la place de faire un fread d'un octet, il est possible de faire un fread de BUFSIZE octes, puis de boucler dans la chaine de caractères obtenue.
Quelle serait la différence ?

Merci
12/06/2012, 17h33
matafan

La différence est qu'en lisant tout un bloc d'un coup tu as mois d'appels de fonctions (fread), ce qui peux être très légèrement plus efficace.

Diogène a déjà répondu à tes deux 1ères questions. Si la taille du fichier est plus petite que BUFSIZE, alors la 1ère lecture sortira de la boucle où feof() indiquera la fin du fichier. Si le fichier est plus gros, alors on fait plusieurs tours de boucles puisque fread() renverra BUFSIZE tant qu'on n'arrive pas à la fin du fichier.

En passant, BUFSIZE est juste la taille par défaut du buffer de la libc. Rien ne t'oblige à lire des blocs de BUFSIZE. Rien ne te garantie non plus que la libc lit par blocs de BUFSIZE. D'ailleurs que je sache BUFSIZE n'est pas une macro standard, elle peut très bien ne pas être définie.
14/06/2012, 13h38
Nico_stras

ok, je comprends mieux.
Je croyais que la fonction

Code:

n = fread(buf,1,BUFSIZE,f);

renvoyait 1 caractère.

Quel est le rôle du 2ème arguement, sachant que c'est BUFSIZE qui défini le nombre d'octets lus ?

Comment est défini BUFSIZE ? Est ce que la valeur est modifiable ou est directement dépendante de la plateforme ?
14/06/2012, 14h32
Bktero

Il suffit de constater le manuel de la fonction : http://man.developpez.com/man3/fread.3.php

Citation:

Code:

size_t fread (void *ptr, size_t size, size_t nmemb, FILE *stream);

La fonction fread lit nmemb éléments de données, chacun d'eux représentant size octets de long, depuis le flux pointé par stream, et les stocke à l'emplacement pointé par ptr.

Ton fread lit pas BUFSIZE octets parce que le deuxième argument vaut 1 (1 octet).