Available in

(3) (3)/fr (3)/ja

Contents

NOM

fmemopen, open_memstream, open_wmemstream − 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);

#define _GNU_SOURCE
#include <wchar.h>

FILE *open_wmemstream(wchar_t **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. Depuis la glibc 2.9, la lettre « b »peut être spécifiée comme second caractère de mode. Ceci fournit le mode binaire : une écriture n’implique pas d’ajouter un caractère nul de terminaison et fseek(3) SEEK_END est relative à la fin du tampon (c−a−d la valeur spécifié par size) au lieu de la taille de la chaîne courante.

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 n’est pas inclus dans la valeur de la taille stockée dans sizeloc.

La position du flux de fichier peut être changée avec fseek(3) ou fseeko(3). Déplacer la position après la fin des données déjà écrites remplit l’intervalle vide avec des zéros.

La fonction open_wmemstream() est similaire à open_memstream(), mais elle opère sur les caractères larges et non sur des octets.

VALEUR RENVOYÉE

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

VERSIONS

fmemopen() est open_memstream() sont déjà disponibles dans la glibc 1.0.x. open_wmemstream() est disponible depuis la glibc 2.4.

CONFORMITÉ

POSIX.1−2008. Ces fonctions ne sont pas spécifiées dans POSIX.1−2001 et ne sont que rarement disponible sur d’autres systèmes.

NOTES

Il n’y a pas de descripteur de fichier associé avec le flux renvoyé par ces fonctions (par exemple, fileno(3) retournera une erreur si elle est appelée avec un tel flux).

BOGUES

Avant la glibc 2.7, un positionnement après la fin d’un flux crée par open_memstream() n’agrandit pas le tampon ; l’appel à fseek() échoue et renvoie −1.

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

Source du programme
#define _GNU_SOURCE
#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;

if (argc != 2) {

fprintf(stderr, "Usage: %s <file>\n", argv[0]);

exit(EXIT_FAILURE);

}

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), fopencookie(3), feature_test_macros(7)

COLOPHON

Cette page fait partie de la publication 3.23 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 [AT] gmail.com> et l’équipe francophone de traduction de Debian.

Veuillez signaler toute erreur de traduction en écrivant à <debian−l10n−french [AT] lists.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> ».

COMMENTS

blog comments powered by Disqus