comment ca marche ?!

heu comment ça marche quoi, pourais tu être un peu plus précis?

Ca marche comme ça peut ?  
 
La question est-elle "comment stocker un fichier en mémoire pour pas avoir à le relire à chaque accès" ?

bah, y faut stocker tout le contenu du fichier dans
char szBufFile[MAXFIC]
MAXFIC étant la taille maxi de ton fichier en octets.
ensuite, tu fais un bête fscanf dans ton buffer j'imagine (ça, j'utilise qd même pas trop... les MFC c vachement mieux :-D)

[edtdd]--Message édité par El_Gringo--[/edtdd]

et c koi les MFC ??

CARBON_14 a écrit a écrit : Ca marche comme ça peut ?     La question est-elle "comment stocker un fichier en mémoire pour pas avoir à le relire à chaque accès" ?

yep c tt a fais ca

Stocker le contenu d'un fichier en mémoire est "facile" (ouvrir en mode binaire pour éviter de perdre des caractères) quand il y tient. C'est plus rusé si le fichier est très gros, car faut découper (je connais que le principe) et gérer les adresses des bouts chargés pour s'y retrouver....

c koi le principe ?
apres le fopen tu fais koi ?

Y a un truc qui est super c la doccumentation, ce genre de truc est expliqué dans nimportequel bouquin de programmation ou tutorial sur le net.... enfin on va quand même te donner la solution:
 
#include <stdio.h>
 
int main()
{
   FILE          *pFile;
   int            taille
   unsigned char *buffer;
 
   buffer=NULL;
   if(pFile=fopen("monFichier","rb" ))
   {
      fseek(pFile,0,SEEK_END);
      taille=ftell(pFile);
      buffer=(unsigned char*)malloc(taille);
       
      fread(buffer,1,taille,pFile);
      fclose(pFile);
   }
}

[edtdd]--Message édité par LetoII--[/edtdd]

la "bufferisation" ne se fait pas obligatoirement d'un seul bloc ! typiquement, on bufferise par morceaux (taille fixée) : on lit X caractères que l'on met dans un buffer, dès que l'on a besoin de caractères supplémentaires, on lit les X caractères suivants. tout le pb est dans la gestion des mots qui commencent à la fin d'un bloc et finissent dans le suivant...
 
d'ailleurs, si vous utilisez un FILE *, hé bien, hé-hé-hé, inutile de bufferiser, ça l'est déjà
 
il me semble que dans le K&R (Kernighan et Ritchie) c'est expliqué comment ça marche... ouais, attend, je l'ai là...
 "feuillette-feuillette-feuillette-feuillette-feui
llette-feuillette-feuillette-feuillette-feuillette
..."  
 
bingo : chapitre 8, dans la 2nde édition anglaise, c'est page 169.
 
Mogi.
 
ps : il manque un 'tit fseek dans le prog de Leto II :
 
     fseek(pFile,0,SEEK_END);  
     taille=ftell(pFile);
     fseek(pFile,0,SEEK_SET);  
     buffer=(unsigned char*)malloc(taille);  
                         
     fread(buffer,1,taille,pFile);

exacte, ça aide de se remettre au début du fichier pour lire

au fait, faut jamais caster malloc....

 
et pourquoi don?

perso je caste, je caste, je caste, je caste, je caste, ....

Godbout a écrit a écrit : perso je caste, je caste, je caste, je caste, je caste, ....

 
tout pareil... du cast, du cast, du cast

Moi, je caste aussi...

faut qu'il arréte de fumer tomate77

pk parce que malloc renvoie un void *, qui n a jamais besoin d etre caste...
 
sinon pk renvoyer un void *
 
le cast c est mal

 
En fait.. vous avez tous les deux raison!
 
En C, au départ il n'y avait que des char *
donc malloc renvoyait un char * qu'il fallait caster.
 
Puis les gens du C se sont dit "ce serait bien qu'on ait
un pointeur universel", puisque de toute facon C est assez faiblement type comme langage. Donc ils ont inventé le void *.
et la caracteristique de void * c'est qu'on peut caster
tout pointeur en void * et void * peut etre casté en tout pointeur.
donc  
void * mama;
char * toto = mama; // c'est valide en C
mama = toto; // c'est valide en C
 
Puis est arrivé C++ qui pour embeter tout le monde a décidé
d'être plus fortement typé, d'empêcher des conversions dangereuses (surtout avec l'arrivée des différents types de cast). Donc en C++, il est légal de caster implicitement
tout pointeur en void * (le pointeur générique)
par contre l'inverse n'est plus possible sans un cast explicite.
donc en C++, il faut caster explicitement sinon ca plante:
char * toto = (char*) malloc(n* sizeof(char));  
 
Vous allez dire: oui mais a quoi ca sert d'utiliser malloc en C++
quand on a new qui fait le boulot et qui appelle le constructeur et qui renvoie le bon type de pointeur?
Ben en fait new par défaut est implanté avec malloc. Donc il reste présent tout de même, il est d'ailleurs possible de surcharger l'opérateur new, et de faire soi-meme l'allocation.
 
De plus, on peut écrire des programmes C-Style en C++ pour
je ne sais quelle raison, donc malloc ca existe toujours.
 
A+
LEGREG

 
http://www.isty-info.uvsq.fr/~rume [...] 2.html#q_1
 

 
Mais ... c'est pas à l'OS de se charger de tout cela ? Il se fait sa popote ... en optimisant à l'aide de la pagination et autre (plusieurs processus lisant le même fichier partageront le même "buffer" ...)
Je dirais même : bufferiser un fichier, c'est *mal*, car c'est déjà fait par l'OS, et on le refait une seconde fois, bref on bouffe de le mémoire pour rien (et en plus on perd du temps en recopies inutiles ...)
A moins que quelque chose m'ait échappé ...