lecture de fichier binaire et stockage en mémoire - débutant

In 'fr.comp.lang.c', mat <nobody@thehouesacge.com> wrote:

je voudrais lire un fichier binaire (un fichier jpg par exemple) et
enregistrer son contenu en mémoire pour ensuite faire un traitement
dessus.
j'ai donc écrit le programme suivant :

#define BIN_BUFFER_SZ 8291*20 // définit la taille maximale de mon
buffer

Pour éviter les mauvaises surprises :

#define BIN_BUFFER_SZ (8291*20)

Ca fait quand même : 165620. Il est possible que ce soit trop grand pour un
size_t sur ton implémentation.

printf ("SIZE MAX = %lu ", (unsigned long)((size_t) -1));

int main ( void ) {
FILE *fp;
char *buffer;
char *data;

Espérons que ces variables seront initialisées un jour... Il n'est pas très
prudent de définir un pointeur sans lui donner une valeur. Si on hésite, NULL
est parfait! Ca permet au moins de le tester.

size_t file_size;

fp = fopen("fichier.jpg", "rb");

Ok, pour 'fp'.

if ( fp == NULL ) {
// fichier non trouvé
return 0;
}

buffer = (char *)malloc(BIN_BUFFER_SZ);

Ok, mais attention :

- Le cast est inutile.
- S'assurer que l'on a inclus <stdlib.h>
- malloc() peut échouer. Avant d'utiliser le pointeur, il faut tester qu'il
n'est pas NULL.

while(!feof(fp)) {

Non. Lire la FAQ. feof() ne fait pas ce que tu crois (C != Pascal).

file_size = fread(buffer,1,BIN_BUFFER_SZ,fp);

Comme l'indique ton livre de C, c'est la valeur retournée par fread() qu'il
faut tester pour savoir si la lecture s'est arrétée. feof() et ferror()
permettent d'en déterminer la cause.

}
fclose(fp);

// allocation de la taille exacte des données lues
data = (char *) malloc(file_size);
memcpy(data,buffer,file_size);


/// .... suite du traitement sur data

return 1;

Pourquoi 1? 0 ou EXIT_SUCCESS.

}

--
-ed- emdelYOURBRA@noos.fr [remove YOURBRA before answering me]
The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html
<blank line>
FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/

Emmanuel Delahaye wrote:

In 'fr.comp.lang.c', mat <nobody@thehouesacge.com> wrote:

je voudrais lire un fichier binaire (un fichier jpg par exemple) et
enregistrer son contenu en mémoire pour ensuite faire un traitement
dessus.
j'ai donc écrit le programme suivant :

#define BIN_BUFFER_SZ 8291*20 // définit la taille maximale de mon
buffer

ok merci Emmanuel,
j'ai réécrit mon programme que voici :


#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <errno.h>
#include <string.h>

#define BIN_BUFFER_SZ (8291*20)

int main ( void )
{
FILE *fp = NULL;
char *buffer = NULL;
char *data = NULL;
size_t file_size = 0;

fp = fopen("test.jpg", "rb");
if ( fp == NULL ) {
fprintf(stdout, "fichier non trouvén");
return EXIT_FAILURE;
}

buffer = malloc(BIN_BUFFER_SZ);
if ( buffer == NULL ) {
fprintf(stdout, "erreur malloc buffern");
return EXIT_FAILURE;
}

file_size = fread(buffer,1,BIN_BUFFER_SZ,fp);
if ( !file_size )
fprintf(stdout, "no data was read.n");
fprintf(stdout, "reading : %dn", file_size);
fprintf(stdout, "Buffer : %sn", buffer);
fprintf(stdout, "Size Buffer : %dn", sizeof(buffer));

if (ferror(fp)) {
fprintf(stdout, "erreur fichier : %sn", strerror(errno));
return EXIT_FAILURE;
}
fclose(fp);
fprintf(stdout, "file size : %dn", file_size);

data = malloc(file_size);
if ( data == NULL ) {
fprintf(stdout, "erreur malloc datan");
return EXIT_FAILURE;
}
memcpy(data,buffer,file_size);


fprintf(stdout, "Data : %sn", data);

return EXIT_SUCCESS;
}


dernier problème, je ne récupere pas toutes les données dans la variable
buffer. sizeof(buffer) me renvoi 4, ne devrait-il pas me renvoyer
file_size ?

est-il nécessaire de passer par le memcpy? est-ce que le buffer
contiendra plus de données que nécessaire ?

merci pour tes remarques.

mat

In 'fr.comp.lang.c', mat <nobody@thehouesacge.com> wrote:

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>

Pas standard et inutile. Tout est déjà dans <stdlib.h>

#include <errno.h>
#include <string.h>

#define BIN_BUFFER_SZ (8291*20)

Pourquoi cette taille ?

int main ( void )
{
FILE *fp = NULL;
char *buffer = NULL;
char *data = NULL;
size_t file_size = 0;

fp = fopen("test.jpg", "rb");
if ( fp == NULL ) {
fprintf(stdout, "fichier non trouvén");

fprintf(stdout, "fichier non trouven");

Toutes les consoles n'interprètent pas les caractères accentués de la même
façon. Pour être portable : pas d'accents!

return EXIT_FAILURE;
}

buffer = malloc(BIN_BUFFER_SZ);

Allouer un buffer de taille fixe est toujours surpenant. Pourquoi pas un
tableau? A cause de la taille? Alors pourquoi une telle taille?

Attention. Si la valeur est trop grande, elle est tronquée en silence, et la
taille réellement allouée peut être bien inférieure.

Exemple extrème: Si ton size_t accepte 65535 et que tu demandes 65537 bytes,
en fait tu n'en auras qu'un! Il vaut mieux passer par une valeur
intermédiaire :

size_t size = BIN_BUFFER_SZ;

et vérifier au moins une fois que la taille est correcte :

#define DBG 1 /* 0 | 1 */
<...>

#if DBG
printf ("size = %lun", (unsigned long) size);
#endif

Ensuite seulement, on peut écrire la suite du programme.

buffer = malloc(size);

if ( buffer == NULL ) {
fprintf(stdout, "erreur malloc buffern");
return EXIT_FAILURE;
}

file_size = fread(buffer,1,BIN_BUFFER_SZ,fp);

file_size = fread (buffer, 1, size, fp);

if ( !file_size )

Correct, mais peu clair. La vérité est :

if ( file_size >= 1)

{

fprintf(stdout, "no data was read.n");
}

Afin de bien préciser tes intentions.

fprintf(stdout, "reading : %dn", file_size);
fprintf(stdout, "Buffer : %sn", buffer);

Non! Tu as lu un fichier binaire. Il n'est pas garanti que les données soient
du texte au format chaine C. Les fonctions chaines sont donc /interdites/.

fprintf(stdout, "Size Buffer : %dn", sizeof(buffer));

Non! Comme sont nom ne l'indique pas (manque un préfixe 'p_'), 'buffer' est
un pointeur. Celui-ci a une taille fixe qui dépend de l'implémentation (2, 4
etc.). L'information que tu cherches est maintenant dans 'size'.

fprintf(stdout, "Size Buffer : %lun", (unsigned long) size);

if (ferror(fp)) {
fprintf(stdout, "erreur fichier : %sn", strerror(errno));
return EXIT_FAILURE;
}
fclose(fp);
fprintf(stdout, "file size : %dn", file_size);

Le format correct pour un size_t est "%zu". mais c'est une nouveauté de C99.
Si ton compilateur n'est pas C99, il faut utiliser le plus grand format non
signé disponible qui est 'unsigned long'.

fprintf(stdout, "file size : %lun", (unsigned long) file_size);

data = malloc(file_size);
if ( data == NULL ) {
fprintf(stdout, "erreur malloc datan");
return EXIT_FAILURE;
}
memcpy(data,buffer,file_size);


fprintf(stdout, "Data : %sn", data);

Non, pour les raisons invoquées plus haut.

Penser à

- Fermer le fichier
- Libérer la mémoire.

return EXIT_SUCCESS;
}

--
-ed- emdelYOURBRA@noos.fr [remove YOURBRA before answering me]
The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html
<blank line>
FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/

Emmanuel Delahaye wrote:

In 'fr.comp.lang.c', mat <nobody@thehouesacge.com> wrote:

j'ai donc écrit le programme suivant :

<snip>

Je ferais comme ça:

ok merci beaucoup!
pour résoudre le problème de la taille du buffer, j'ai écrit le prog
suivant qui récupére la taille du fichier pour allouer la taille
correcte du buffer. J'économise ensuite la création du deuxiéme pointeur
dans lequel je recopiais les données du premier.

est-ce que la méthode que j'utilise est la meilleure façon de récupérer
la taille du fichier?

pour info je suis sous GNU/Linux (2.4.18) et j'utilise gcc version
2.95.4. le résultat de "SIZE MAX = %lu ", (unsigned long)((size_t) -1)
était SIZE MAX = 4294967295

Merci beaucoup pour ton aide, je commence à y voir plus clair!

mat


#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>

#define DBG 1

size_t _get_file_size ( fp )
FILE *fp;
{
size_t size = 0;
if ( fseek(fp, 0, SEEK_END) < 0 )
fprintf(stdout, "fseek failed on file : %sn", strerror(errno));
else
size = ftell(fp);
return size;
}

int main (void)
{
int ret = EXIT_SUCCESS;
FILE *fp = fopen ("test.jpg", "rb");

if (fp != NULL)
{
size_t st_size = _get_file_size(fp);

// rewind file to beginning
if ( fseek(fp, 0, SEEK_SET) < 0 )
{
fprintf(stdout, "fseek failed, unable to rewind : %sn",
strerror(errno));
ret = EXIT_FAILURE;
}
else
{
char *p_buffer = malloc (st_size);
#if DBG
printf ("size = %lun", (unsigned long) st_size);
#endif

if (p_buffer != NULL)
{
size_t file_size = fread (p_buffer, 1, st_size, fp);

if (file_size < 1)
{
fprintf (stdout, "no data was read.n");

if (ferror (fp))
{
fprintf (stdout, "file error : %sn", strerror (errno));
ret = EXIT_FAILURE;
}
}
else if ( file_size != st_size )
{
fprintf(stdout, "read bytes from read differs from stat.s_tsize !n");
ret = EXIT_FAILURE;
}
else
{
fprintf (stdout, "read : %lun", (unsigned long)
file_size);
}

fclose (fp);

/* traitement sur p_buffer */

free (p_buffer);
}
else
{ fprintf (stdout, "error malloc p_buffern");
ret = EXIT_FAILURE;
}
}
}
else
{
fprintf (stdout, "no file foundn");
ret = EXIT_FAILURE;
}
return ret;
}

In 'fr.comp.lang.c', mat <nobody@thehouesacge.com> wrote:

pour résoudre le problème de la taille du buffer, j'ai écrit le prog
suivant qui récupére la taille du fichier pour allouer la taille
correcte du buffer. J'économise ensuite la création du deuxiéme pointeur
dans lequel je recopiais les données du premier.

Le concept est bon.

est-ce que la méthode que j'utilise est la meilleure façon de récupérer
la taille du fichier?

La méthode est efficace mais attention, elle peut renvoyer un nombre de byte
supérieur au nombre réel, mais ce n'est pas vraiment génant.

pour info je suis sous GNU/Linux (2.4.18) et j'utilise gcc version
2.95.4. le résultat de "SIZE MAX = %lu ", (unsigned long)((size_t) -1)
était SIZE MAX = 4294967295

Et sur ma machine (avec un compilateur 16-bit), elle donnait 65535.

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>

#define DBG 1

size_t _get_file_size ( fp )
FILE *fp;

Huh! Dans quel bouquin as-tu appris ce vieux style? Depuis 1989, on écrit:

size_t _get_file_size (FILE *fp)

Le prefix '_' est acceptable car il est suivit d'une minuscule, mais il
apporte plutôt de la confusion qu'autre chose.

size_t get_file_size (FILE *fp)

{
size_t size = 0;
if ( fseek(fp, 0, SEEK_END) < 0 )

Il est recommandé de toujours mettre les {}, un code ayant tendance à
s'agrandir, autant être prêt. Ca clarifie aussi les intentions du programmeur
et facilite la relecture (et le contrôle visuel).

fprintf(stdout, "fseek failed on file : %sn", strerror(errno));
else
size = ftell(fp);

Attention, le type retourné par ftell() est 'long'. Or un long ne tient pas
forcément dans un size_t (Chez moi, en 16-bit, ça couine).

Ca signifie que ton code fonctionne sur ta machine 32-bit (et sur la mienne
avec un compilateur 32-bit), mais qu'il n'est pas portable. C'est un problème
ou non, c'est toi qui vois.

return size;
}

int main (void)
{
int ret = EXIT_SUCCESS;
FILE *fp = fopen ("test.jpg", "rb");

if (fp != NULL)
{
size_t st_size = _get_file_size(fp);

// rewind file to beginning
if ( fseek(fp, 0, SEEK_SET) < 0 )

J'aurais mis ça dans get_file_size(). On a pas besoin de connaitre les
dessous de cette fonction.

{
fprintf(stdout, "fseek failed, unable to rewind : %sn",
strerror(errno));
ret = EXIT_FAILURE;
}
else
{
char *p_buffer = malloc (st_size);
#if DBG
printf ("size = %lun", (unsigned long) st_size);
#endif

if (p_buffer != NULL)
{
size_t file_size = fread (p_buffer, 1, st_size, fp);

if (file_size < 1)
{
fprintf (stdout, "no data was read.n");

if (ferror (fp))
{
fprintf (stdout, "file error : %sn", strerror (errno));
ret = EXIT_FAILURE;
}
}
else if ( file_size != st_size )
{
fprintf(stdout, "read bytes from read differs from stat.s_tsize
!n"); ret = EXIT_FAILURE;
}
else
{
fprintf (stdout, "read : %lun", (unsigned long)
file_size);

C'est ici que doit se faire le traitement

/* traitement sur p_buffer */

}

fclose (fp);

/* traitement sur p_buffer */

Non, ce n'est pas là que doit se faire le traitement, mais plus haut. Ou
alors, il faut le soumettre a la condition 'ret == EXIT_SUCCESS'.

free (p_buffer);
}
else
{ fprintf (stdout, "error malloc p_buffern");
ret = EXIT_FAILURE;
}
}
}
else
{
fprintf (stdout, "no file foundn");
ret = EXIT_FAILURE;
}
return ret;
}

Enfin, il est d'usage que les chaines d'erreur soient envoyées vers 'stderr'
plutôt que 'stdout'.

--
-ed- emdelYOURBRA@noos.fr [remove YOURBRA before answering me]
The C-language FAQ: http://www.eskimo.com/~scs/C-faq/top.html
<blank line>
FAQ de f.c.l.c : http://www.isty-info.uvsq.fr/~rumeau/fclc/

mat wrote:

Emmanuel Delahaye wrote:

In 'fr.comp.lang.c', mat <nobody@thehouesacge.com> wrote:

je voudrais lire un fichier binaire (un fichier jpg par exemple) et
enregistrer son contenu en mémoire pour ensuite faire un traitement
dessus. j'ai donc écrit le programme suivant :

#define BIN_BUFFER_SZ 8291*20 // définit la taille maximale de mon
buffer

ok merci Emmanuel,
j'ai réécrit mon programme que voici :


#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <errno.h>
#include <string.h>

#define BIN_BUFFER_SZ (8291*20)

int main ( void )
{
FILE *fp = NULL;
char *buffer = NULL;
char *data = NULL;
size_t file_size = 0;

fp = fopen("test.jpg", "rb");
if ( fp == NULL ) {
fprintf(stdout, "fichier non trouvén");
return EXIT_FAILURE;
}

buffer = malloc(BIN_BUFFER_SZ);
if ( buffer == NULL ) {
fprintf(stdout, "erreur malloc buffern");

fprintf(stderr, ....)

stdout est pour les sorties *normales* du programme.
stderr est pour les messages d'erreur.

return EXIT_FAILURE;
}

file_size = fread(buffer,1,BIN_BUFFER_SZ,fp);
if ( !file_size )
fprintf(stdout, "no data was read.n");
fprintf(stdout, "reading : %dn", file_size);
fprintf(stdout, "Buffer : %sn", buffer);
fprintf(stdout, "Size Buffer : %dn", sizeof(buffer));

idem

if (ferror(fp)) {
fprintf(stdout, "erreur fichier : %sn", strerror(errno));

idem

return EXIT_FAILURE;
}
fclose(fp);
fprintf(stdout, "file size : %dn", file_size);

Est-ce une sortie normale du programme ? Sinon, -> stderr

data = malloc(file_size);
if ( data == NULL ) {
fprintf(stdout, "erreur malloc datan");
return EXIT_FAILURE;
}
memcpy(data,buffer,file_size);


fprintf(stdout, "Data : %sn", data);

Est-ce une sortie normale du programme ? Sinon, -> stderr

return EXIT_SUCCESS;

Tu n'a pas libéré les zones mémoires sur lesquelles pointent data et
buffer. Fuite mémoire possible selon la plateforme.

}


dernier problème, je ne récupere pas toutes les données dans la variable
buffer. sizeof(buffer) me renvoi 4, ne devrait-il pas me renvoyer
file_size ?

Non. buffer est un pointeur sur un bloc mémoire. L'opérateur sizeof
retourne la taille de la variable (donc ici la taille d'un pointeur sur
char pour ta plateforme), pas la taille du bloc mémoire sur lequel
pointe un pointeur. Pour t'en assurer, il te suffit de faire ça :

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
char *ptr = NULL;
fprintf(stdout, "before malloc, size of ptr is %dn", sizeof (ptr));

ptr = malloc(20);
if (!ptr) {
fprintf(stderr, "malloc failedn");
return EXIT_FAILURE;
}
fprintf(stdout, "after malloc, size of ptr is %dn", sizeof (ptr));

strcpy(ptr, "allo brest");
fprintf(stdout, "after strcpy, size of ptr is %dn", sizeof (ptr));

free(ptr);
ptr = NULL;

return EXIT_SUCCESS;
}

Bruno

Bruno Desthuilliers wrote:

Non. buffer est un pointeur sur un bloc mémoire. L'opérateur sizeof
retourne la taille de la variable (donc ici la taille d'un pointeur sur
char pour ta plateforme), pas la taille du bloc mémoire sur lequel
pointe un pointeur. Pour t'en assurer, il te suffit de faire ça :

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
char *ptr = NULL;
fprintf(stdout, "before malloc, size of ptr is %dn", sizeof (ptr));

ptr = malloc(20);
if (!ptr) {
fprintf(stderr, "malloc failedn");
return EXIT_FAILURE;
}
fprintf(stdout, "after malloc, size of ptr is %dn", sizeof (ptr));

strcpy(ptr, "allo brest");
fprintf(stdout, "after strcpy, size of ptr is %dn", sizeof (ptr));

free(ptr);
ptr = NULL;

return EXIT_SUCCESS;
}

Bruno

ok merci.
j'avais clairement pas compris ce que faisait sizeof.
je voudrais savoir s'il est possible de renvoyer la taille occupée en
mémoire par le pointeur ptr ? (je sais que je la connais car je l'alloue
mais c'est pour savoir si c'est possible de la savoir à partir du pointeur).
et enfin je voudrais savoir comment est-ce que je peux faire (si
possible) pour imprimer sur la sortie standard le contenu du pointeur,
ce qui dans mon cas imprimera le contenu du fichier binaire que j'ai lu.
un fprintf(stdout, "contenu buffer : %sn", ptr) me renvoie en fait les
4 premiers octets (== sizeof(p_buffer)) du fichier .jpg. est-ce possible ?

merci pour toutes tes remarques.

mat

Emmanuel Delahaye wrote:

In 'fr.comp.lang.c', mat <nobody@thehouesacge.com> wrote:

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>

#define DBG 1

size_t _get_file_size ( fp )
FILE *fp;

Huh! Dans quel bouquin as-tu appris ce vieux style? Depuis 1989, on écrit:

size_t _get_file_size (FILE *fp)

en fait j'ai pas de bouquin, j'ai vu ce style dans le code source d'un
ami et il m'a plu.

Le prefix '_' est acceptable car il est suivit d'une minuscule, mais il
apporte plutôt de la confusion qu'autre chose.

size_t get_file_size (FILE *fp)

ok.

fprintf(stdout, "fseek failed on file : %sn", strerror(errno));
else
size = ftell(fp);

Attention, le type retourné par ftell() est 'long'. Or un long ne tient pas
forcément dans un size_t (Chez moi, en 16-bit, ça couine).

Ca signifie que ton code fonctionne sur ta machine 32-bit (et sur la mienne
avec un compilateur 32-bit), mais qu'il n'est pas portable. C'est un problème
ou non, c'est toi qui vois.

ça ne devrait pas poser de problème vu que ce prog sera uniquement
utilisé sur ma machine, mais autant prendre de bonnes habitudes dès le
départ, je t'avouerais que le cas 16-bit 32-bit m'avais complétement
échappé.

Enfin, il est d'usage que les chaines d'erreur soient envoyées vers 'stderr'
plutôt que 'stdout'.

oui, je l'avais fait à la va-vite, j'ai corrigé.

en tout cas merci beaucoup pour ta patience et tes commentaires, voilà
la dernière version du prog corrigé, je pense que ça devrait être bon
cette fois-ci :)
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>

#define DBG 1

unsigned long get_file_size ( fp )
FILE *fp;
{
unsigned long size = 0;
if ( fseek(fp, 0, SEEK_END) < 0 )
{
fprintf(stderr, "fseek failed on file : %sn", strerror(errno));
}
else
{
size = ftell(fp);
}
// rewind after reading
if ( fseek(fp, 0, SEEK_SET) < 0 )
{
fprintf(stderr, "fseek failed, unable to rewind : %sn",
strerror(errno));
size = 0;
}
return size;
}

int main (void)
{
int ret = EXIT_SUCCESS;
FILE *fp = fopen ("test.jpg", "rb");

if (fp != NULL)
{
unsigned long st_size = get_file_size(fp);
if ( st_size == 0 )
{
fprintf(stderr, "get_file_size returned 0 !n");
ret = EXIT_FAILURE;
}
else
{
char *p_buffer = malloc (st_size);
#if DBG
fprintf (stdout, "size = %lun", st_size);
#endif

if (p_buffer != NULL)
{
size_t file_size = fread (p_buffer, 1, st_size, fp);

if (file_size < 1)
{
fprintf (stderr, "no data was read.n");

if (ferror (fp))
{
fprintf (stderr, "file error : %sn", strerror (errno));
ret = EXIT_FAILURE;
}
}
else if ( file_size != st_size )
{
fprintf(stderr, "read bytes from read differs from fseek size !n");
ret = EXIT_FAILURE;
}
else
{
fprintf (stdout, "read : %lun", (unsigned long) file_size);
/* traitement sur p_buffer */
}

fclose (fp);


free (p_buffer);
}
else
{
fprintf (stderr, "error malloc p_buffern");
ret = EXIT_FAILURE;
}
}
}
else
{
fprintf (stderr, "no file foundn");
ret = EXIT_FAILURE;
}
return ret;
}


il me reste cependant deux question, que j'ai aussi posées à Bruno à la
suite de son post.

- est-il possible à partir d'un pointeur de connaître la taille mémoire
qu'il occupe?
- est-il possible d'imprimer le contenu de p_buffer sur la sortie
standard pour que le contenu du fichier s'affiche à l'écran?

merci.

mat

DINH Viêt Hoà wrote:

- est-il possible d'imprimer le contenu de p_buffer sur la sortie
standard pour que le contenu du fichier s'affiche à l'écran?

Tout à fait, sauf si éventuellement ta sortie standard ne sait pas
afficher tous les caractères contenus dans le fichier.

salut,
ma sortie peut effectivement le faire, en faisant un cat test.jpg le
contenu s'affiche correctement. avec quelles fonctions puis-je le faire
en C ?

merci.

mat

salut,
ma sortie peut effectivement le faire, en faisant un cat test.jpg le
contenu s'affiche correctement. avec quelles fonctions puis-je le faire
en C ?

pas sous forme d'image. Mais un ensemble de données éventuellement
incompréhensible, sauf si tu sais lire dans la matrice.

la sortie standard ne peut afficher que du texte.

--
DINH V. Hoa,

"oui, mais je veux pas de chat dans mon appart, désolé" -- Arsunique