Bonjour, j'ai un problème apparement très simple, je me suis pris la tête toute la nuit dernière et aujourdh'ui sur ce truc, impossible de débloquer la situation donc je ne sais plus quoi faire, permettez-moi de vous soumettre la chose.
 
Je souhaite tout simplement lire dans un fichier (de n'importe quel format), mettre ce que je lis dans un buffer de données de type char (typé ainsi que je pourrais lire octet par octet).
Voici ma fonction :
 
char* fichier_lire_bloc(char *nom_fichier,int size)
{  
       int f= open(nom_fichier, O_RDONLY);
      char *donnees=(char*)malloc(sizeof(char)*size);
   
     if(read(f, donnees, size) < 0)
     {
            perror("fichier_lire_bloc" );
            close(f);
            return -1;
     }*/
     printf(" sizeof(donnees) lire_bloc2 :  %d\n",(int)sizeof(donnees2));
     printf("voici les données \n %s \n",donnees2);
   
       close(f);
 
       return donnees;
}
 
Simple non ? le problème est qu'a l'affichage sur l'écran, je n'ai que 4 caractères d'écrit et si j'essaye d'écrire mon buffer dans un autre fichier (ce qui est mon but), sa ne m'écrit que ces quelques caractères.
J'ai tout essayé, de déclarer mon buffer en static (char donnees[4096]), lire d'autres taille (je voudrais lire des blocs de 4096)...
 
 
Auriez-vous une solution, y a t'il quelque chose qui vous saute aux yeux ? Je n'en peux plus de m'arracher les cheveux sur cette partie, je deviens fou    
Merci d'avance pour vos réponse

 
Je suis pas un speialiste du C mais voila un code réalisé il y'a quelques temps qui fonctionnait bien. Il a l'avantage d'utiliser la fonction fopen plus portable (si mes souvenirs sont bons) que open.
 
Après je dis peut être une connerie mais je sais qu'un pointeur est sur certain systèmes codé sur quatre octets. Un char étant codé sur un octet une erreur telle que décrite me fait penser que tu essaye d'imprimer un pointeur et non pas ta chaine de char.
 
As tu essayé un strlen()??

1 - aujourd'hui en 2008, ca ne sert à rien de caster les (void *) sur malloc(), à part cacher des problèmes de typage.

2 - sizeof est un opérateur de compilation, il ne pourra jamais te retourner le nombre d'éléments dans ton buffer de lecture. En l'occurence, il te retournera 4, qui est bien la taille d'un pointeur de char (une adresse 32 bits).

3 - si tu veux utiliser proprement read(), tu dois vérifier le code de retour, qui te donnera le nombre d'octets lus (si la valeur de retour est >0), 0 si tu atteins la fin de fichier (EOF), ou éventuellement -1 s'il y a une erreur. Tu peux effectivement demander de lire 256 octets, mais au final en avoir moins (si tu es à moins de 256 octets de la fin de fichier, par exemple).

freepopo, tu as des raisons particulieres pour employer open et read? tu fais du systeme de bas niveau, ou ça t'est imposé? sinon, utilises plutot fopen, fread.
A+,

Merci pour vos réponse, je vais de ce pas essayer ce que vous m'avez préconiser.
 
Je fais de la prog systeme C, c'est un gros gros projet de logiciel peer-to-peer ou je dois tout coder moi-meme. Je vais zieuter du coté de fread.

Amha, dans ce cas, vu que c'est du P2P, tu ferais mieux de laisser tomber les fonctions f* (fread, fopen, ...). Ce sont des fonctions qui opèrent sur des streams (ce sont des fonctions stdio), et si par mégarde tu as le malheur d'oublier un fflush() quelque part, tu vas t'en bouffer les doigts (un exemple typique: des écritures bufferisées mais non flushés, qui font que tu te retrouves rapidement sur des appels à select() bloquant à l'autre bout).

Edit: read() et open() n'ont pas ce problème, elles ne sont pas streamées. Pour une raison évidente, ce sont des syscalls.

Et accessoirement pourquoi dans ton code tu essayes d'afficher "donnees2", alors que dans ta fonction tu manipules "donnees" ?

A priori, ce que tu veux est quelque chose de ce genre ci:

Pour tes tests:
printf(" sizeof(donnees) lire_bloc2 :  %d\n",(int)sizeof(donnees)); ca va te donner la taille d'un char * sur ton systeme, je ne suis pas sur que ce soit ce que tu cherches.
printf("voici les données \n %s \n",donnees); ca risque de foirer si tu n'as pas de '\0' en fin de buffer, car je ne sais pas comment sont tes données.
Je serais toi, je:
recupérerais la taille lue dans une variable definie auparavant:  
if (donneelue = fread(donnees, size, 1, f))
il va falloir gerer le '\0' final a la main si tu veux employer printf, et donc, soit allouer au départ un buffer de size+1 (si ca ne gene pas par la suite pour le buffer retourné) soit copier tes données dans un buffer de taille size+1 pour utilisation avec printf.
A+,

Certes, mais le proto de sa fonction a un nom de fichier, pas un fd, alors...
A+,

 
Tout à fait d'accord
 
Cf ton premier post :
 

Oui, enfin, quand je parlais de prog systeme, je pensais vraie prog systeme unix, parce que la, c'est de l'applicatif avec eventuellement des streams, s'il fait du P2P.
Alors, la multiplication des syscalls n'étant pas recommandée, et fes fXXX etant considérés comme plus portables...autant savoir gerer les fflush
A+,

Merci pour tes précisions mais je ne souhaite pas lire spécialement des caractères , ce ne sont pas des fichiers textes que je lie mais tout (.mp3, .doc etc) et je les transfere en utilisant un buffer de caractere qui a l'avantage "d'écrire octet par octet".
J'affiche la taille du buffer seulement a titre informatif, c'étiat juste pour débuguer et effectivement sa me renvoi 4, la taille du pointeur.

c'est une allusion a quoi?
 
Pour ta fonction, il va falloir tenir compte de la taille des données lues:
Si tu ne lis pas size octets de donnée, consideres tu que c'est une erreur ou non?
- si oui, tu peux remplacer le test
if (fread(donnees, size, 1, f))
par
if (fread(donnees, size, 1, f) == size)
pour ne retourner le buffer que si il est plein
- si non il va falloir retourner le buffer et la taille reellement lue...
 
A+,

fread et fopen sont tout à fait utilisable pour des flux binaires. Le C se fiche un peu de savoir si ce sont des char ASCII ou pas, lui ne voit que des nombres.

Si je comprends bien ta phrase, tu empiles des buffers. Les fonctions f* gèrent déjà un buffer, donc tu empiles des fonctionnalités pour pas grand chose.

Edit: et comme te le montre gilou au dessus, tu complexifies ton code pour pas grand chose. A toi de voir ou tu veux gérer tout ca.

Tout a fait.  
Par contre, j'essayais de lui expliquer plus haut que pour du binaire, fprintf n'est pas particulierement adapté.
( sa ligne printf("voici les données \n %s \n",donnees); ne colle pas pour des données binaires )
S'il tient a afficher le contenu de son buffer pour tracer et debugger, il pourrait plutot passer par un fwrite sur stdout par exemple.
A+,

 
Ah pardon.
 
Oui ca aussi, effectivement