Provided by: manpages-fr-dev_2.80.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

       Si   elles  réussissent  intégralement,  les  fonctions  fmemopen()  et
       open_memstream()  renvoient  un  pointeur  de  type  FILE.  Sinon,  ils
       renvoient NULL et errno est définie avec le code d’erreur.

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 handle_error(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)
               handle_error("fmemopen");

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

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

               s = fprintf(out, "%d ", v * v);
               if (s == -1)
                   handle_error("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)

COLOPHON

       Cette page fait partie de  la  publication  2.80  du  projet  man-pages
       Linux.  Une description du projet et des instructions pour signaler des
       anomalies      peuvent      être       trouvées       à       l’adresse
       http://www.kernel.org/doc/man-pages/.

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> ».