Provided by: manpages-fr-dev_2.64.1-1_all bug

NOM

       fmemopen, open_memstream - Ouvrir de la mémoire comme un flux

SYNOPSIS

       #define _GNU_SOURCE
       #include <stdio.h>

       FILE *fmemopen(void *buf, size_t size, const char *mode);

       FILE *open_memstream(char **ptr, size_t *sizeloc)

DESCRIPTION

       La  fonction  fmemopen()  ouvre un flux qui permet l’accès spécifié par
       mode. Le flux permet d’effectuer des entrées sorties sur la  chaîne  ou
       la  mémoire  du  tampon  pointée  par buf. Ce tampon doit au moins être
       d’une longueur de size octets.

       L’argument mode est le même que celui de la fonction fopen(3). Si  mode
       spécifie  un mode d’ajout (« append mode »), alors la position initiale
       du fichier est définie à la position du premier octet nul  (« \0 »)  du
       tampon ; sinon la position initiale est définie au début du tampon.

       Lorsqu’un  flux ouvert en écriture est vidé (voyez fflush(3)), ou fermé
       (voyez fclose(3)), un octet nul est écrit à la fin du tampon s’il  y  a
       de  la  place.  L’appelant devrait s’assurer qu’un octet supplémentaire
       est disponible dans le tampon  (et  que  size  en  tient  compte)  pour
       permettre ceci.

       Essayer  d’écrire  plus  de size octets dans le tampon crée une erreur.
       (Par défaut, de telles erreurs ne sont seulement visibles  que  lorsque
       le   tampon   stdio  est  vidé.  Désactiver  la  mise  en  tampon  avec
       setbuf(fp, NULL) peut être utile pour détecter les  erreurs  au  moment
       d’une   opération   de   sortie.   Alternativement,   l’appelant   peut
       explicitement définir buf comme un tampon de flux stdio, au même moment
       en  informant  stdio  de  la  taille  du tampon avec setbuffer(fp, buf,
       size)).

       Avec un flux ouvert en lecture, un octet nul dans le tampon ne crée pas
       d’opérations  de  lecture  et renvoie une indication de fin de fichier.
       Une lecture depuis le tampon indiquera  seulement  la  fin  du  fichier
       quand  le  pointeur  de  fichier aura avancé de plus de size octets par
       rapport au début du tampon.

       Si l’argument buf  vaut  NULL,  alors  la  fonction  fmemopen()  alloue
       dynamiquement   un   tampon  de  size  octets.  C’est  utile  pour  les
       applications qui veulent écrire des données dans un  tampon  temporaire
       et  les lire ensuite. Le tampon est automatiquement supprimé lorsque le
       flux est fermé. Notez que l’appelant ne peut pas  obtenir  un  pointeur
       vers  le  tampon  alloué  temporairement  avec  cette  fonction  (c’est
       possible avec open_memstream(), ci-dessous).

       La fonction open_memstream() ouvre un flux en écriture vers un  tampon.
       Le  tampon  est  dynamiquement alloué (comme avec malloc(3)) et grandit
       automatiquement à la demande. Après la fermeture  du  flux,  l’appelant
       doit libérer (free(3)) ce tampon.

       Lorsqu’un  flux est fermé (fclose(3)) ou vidé (fflush(3)), les adresses
       pointées par ptr et sizeloc sont mises à jour, avec respectivement,  un
       pointeur  vers  le  tampon  et  la taille du tampon actuel. Ces valeurs
       restent valides tant que l’appelant n’effectue pas  de  sortie  sur  le
       flux.  Si  d’autres  sorties sont réalisées, alors le flux doit être ne
       nouveau vidé avant d’essayer d’accéder à ces variables.

       Un octet nul est conservé à la fin  du  tampon.  Cet  octet  nest  pas
       inclus dans la valeur de la taille stockée dans sizeloc.

VALEUR RENVOYÉE

       Upon  successful  completion fmemopen()  and open_memstream()  return a
       FILE pointer.  Otherwise, NULL is  returned  and  the  global  variable
       errno is set to indicate the error.

CONFORMITÉ À

       Ces fonctions sont des extensions GNU.

EXEMPLE

       Le  programme  ci-dessous  utilise  fmemopen()  pour  ouvrir  un tampon
       d’entrée et open_memstream() pour ouvrir un tampon de sortie de  taille
       dynamique.  Ce  programme  scrute  la  chaînes  en entrée (récupérée du
       premier argument de la ligne  de  commande  du  programme)  sous  forme
       d’entiers,  et  écrit le carré de ces entiers dans le tampon de sortie.
       Voici un exemple de la sortie produite par ce programme :

       $ ./a.out "1 23 43"
       size=11; ptr=1 529 1849

       #define _GNU_SOURCE
       #include <assert.h>
       #include <string.h>
       #include <stdio.h>
       #include <stdlib.h>

       #define die(msg) do { perror(msg); exit(EXIT_FAILURE); } while (0)

       int
       main(int argc, char *argv[])
       {
           FILE *out, *in;
           int v, s;
           size_t size;
           char *ptr;

           assert(argc == 2);

           in = fmemopen(argv[1], strlen(argv[1]), "r");
           if (in == NULL)
               die("fmemopen");

           out = open_memstream(&ptr, &size);
           if (out == NULL)
               die("fmemopen");

           for (;;) {
               s = fscanf(in, "%d", &v);
               if (s <= 0)
                   break;

               s = fprintf(out, "%d ", v * v);
               if (s == -1)
                   die("fprintf");
           }
           fclose(in);
           fclose(out);
           printf("size=%ld; ptr=%s\n", (long) size, ptr);
           free(ptr);
           exit(EXIT_SUCCESS);
       }

VOIR AUSSI

       fopen(3), feature_test_macros(7)

TRADUCTION

       Cette page de manuel a été traduite  et  mise  à  jour  par  Christophe
       Blaess  <http://www.blaess.fr/christophe/> entre 1996 et 2003, puis par
       Alain Portal <aportal AT univ-montp2 DOT fr> jusqu’en 2006, et  mise  à
       disposition sur http://manpagesfr.free.fr/.

       Les mises à jour et corrections de la version présente dans Debian sont
       directement gérées par Florentin Duneau <fduneau@gmail.com> et l’équipe
       francophone de traduction de Debian.

       Veuillez   signaler   toute   erreur   de   traduction  en  écrivant  à
       <debian-l10n-french@lists.debian.org> ou par un rapport de bogue sur le
       paquet manpages-fr.

       Vous  pouvez  toujours avoir accès à la version anglaise de ce document
       en utilisant la commande « man -L C <section> <page_de_man> ».