Provided by: manpages-fr-dev_4.15.0-9_all 
NOM
fmemopen - Ouvrir de la mémoire en tant que flux
SYNOPSIS
#include <stdio.h>
FILE *fmemopen(void *tampon, size_t taille, const char *mode);
Exigences de macros de test de fonctionnalités pour la glibc (consulter
feature_test_macros(7)) :
fmemopen() :
Depuis la version 2.10 de la glibc :
_POSIX_C_SOURCE >= 200809L
Avant la version 2.10 de la glibc :
_GNU_SOURCE
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 le tampon mémoire pointé par tampon.
L'argument mode spécifie le mode d'ouverture du flux et peut avoir pour valeurs :
r Le flux est ouvert en lecture.
w Le flux est ouvert en écriture.
a Ajout ; le flux est ouvert en écriture, la position initiale du tampon étant
définie au premier octet de valeur zéro.
r+ Le flux est ouvert en lecture et en écriture.
w+ Le flux est ouvert en lecture et en écriture. Le contenu du tampon est écrasé
(autrement dit, '\0') est placé dans le premier octet du tampon.
a+ Ajout ; le flux est ouvert en lecture et écriture, la position initiale du tampon
étant définie au premier octet de valeur zéro.
Le flux conserve la notion de position actuelle qui est l'endroit du tampon où la
prochaine opération d'entrée/sortie aura lieu. La position actuelle est automatiquement
mise à jour par les opérations d'entrées/sorties. Elle peut aussi être définie de manière
explicite à l'aide de fseek(3) et obtenue à l'aide de ftell(3). Dans tous les modes autres
que Ajout, la position actuelle est initialisée au début du tampon. En mode Ajout, si
aucun octet de valeur zéro n'est trouvé dans le tampon, la position actuelle est
initialisée à taille+1.
Si l'argument tampon vaut NULL, alors la fonction fmemopen() alloue un tampon de taille
octets. C'est utile pour les applications qui veulent écrire des données dans un tampon
temporaire et les lire ensuite. La position initiale est définie au début du tampon. Le
tampon est automatiquement supprimé lorsque le flux est fermé. Notez que l'appelant ne
peut pas obtenir de pointeur vers le tampon temporaire alloué avec cette fonction (voir à
ce sujet open_memstream(3)).
Si tampon est différent de NULL, il doit pointer vers un tampon d'une taille minimale de
taille octets alloués par l'appelant.
Lorsqu'un flux ouvert en écriture est vidé (consultez fflush(3)), ou fermé (consultez
fclose(3)), un octet nul est écrit à la fin du tampon s'il y a de la place. Pour ce faire,
l'appelant doit s'assurer qu'un octet supplémentaire est disponible dans le tampon (et que
taille en tient compte).
Avec un flux ouvert en lecture, si le tampon contient des octets de valeur ('\0'), les
opérations de lecture ne renverront pas une indication de fin de fichier. Une lecture
depuis le tampon n'indiquera la fin du fichier que lorsque la position actuelle du tampon
aura atteint la valeur taille.
Les opérations d'écriture s'effectuent soit à la position actuelle (pour les modes autres
que Ajout), ou à une position correspondant à la taille du flux (pour les mode Ajout).
Essayer d'écrire plus de taille octets dans le tampon crée une erreur. Par défaut, de
telles erreurs ne seront visibles (en l'absence de données) que lorsque le tampon stdio
sera vidé. Désactiver cette mise en tampon avec l'appel suivant peut s'avérer utile pour
détecter les erreurs au moment d'une opération de sortie :
setbuf(flux, NULL);
VALEUR RENVOYÉE
En cas de succès, fmemopen() renvoie un pointeur de type FILE. Sinon, elle renvoie NULL et
errno contient le code d'erreur.
VERSIONS
fmemopen() était déjà disponible dans la version 1.0.x. de la glibc.
ATTRIBUTS
Pour une explication des termes utilisés dans cette section, consulter attributes(7).
┌────────────────────────────────────────────────────────┬──────────────────────┬─────────┐
│Interface │ Attribut │ Valeur │
├────────────────────────────────────────────────────────┼──────────────────────┼─────────┤
│fmemopen(), │ Sécurité des threads │ MT-Safe │
└────────────────────────────────────────────────────────┴──────────────────────┴─────────┘
CONFORMITÉ
POSIX.1-2008. Cette fonction n'est pas spécifiée dans POSIX.1-2001 et n'est que rarement
disponible sur d'autres systèmes.
POSIX.1-2008 spécifie que « b » dans mode sera ignoré. Cependant, Technical Corrigendum 1
ajuste la norme pour permettre un traitement spécifique à l'implémentation dans ce cas,
permettant ainsi à la glibc de traiter « b ».
NOTES
Il n'y a pas de descripteur de fichier associé avec le flux renvoyé par cette fonction
(par exemple, fileno(3) retournera une erreur si elle est appelée avec un tel flux).
Avec la version 2.22, le mode binaire a été supprimé (voir ci-dessous), de nombreux bogues
anciens ont été résolus et un nouveau symbole versionné a été créé pour cette interface.
Mode binaire
Avec les versions 2.9 à 2.21, l'implémentation dans la glibc de fmemopen() prenait en
charge un mode «binaire» qui pouvait être activé en spécifiant la lettre 'b' comme second
caractère de mode. Dans ce mode, les opérations d'écriture n'ajoutaient pas de manière
implicite l'octet de valeur zéro terminal, et la valeur SEEK_END du troisième argument de
fseek(3) définissait la position courante à la fin du tampon (autrement dit la valeur
spécifiée par l'argument taille), et non à la longueur de la chaîne courante.
Un bogue de l'API affectait l'implémentation du mode binaire : pour indiquer le mode
binaire, le « b » doit être le second caractère de mode. Ainsi, par exemple, « wb+ » a le
comportement attendu, mais pas « w+b ». Ce n'était pas cohérent avec le traitement de mode
par fopen(3).
Le mode binaire a été supprimé à partir de la version 2.22 de la glibc et un 'b' spécifié
dans mode n'a dorénavant aucun effet.
BOGUES
Avec les versions de la glibc antérieures à 2.22, si taille est égale à zéro, fmemopen()
échoue avec l'erreur EINVAL. Il est plus cohérent dans ce cas de créer un flux renvoyant
la fin de fichier au premier essai de lecture, et c'est ce que fait l'implémentation de la
glibc depuis la version 2.22.
Avec les versions de la glibc antérieures à 2.22, indiquer un mode d'ajout (« a » ou
« a+ ») pour fmemopen() définit la position initiale du fichier au premier octet de valeur
zéro, mais ne force pas l'ajout des écritures suivantes à la fin du flux si la position
actuelle dans le fichier est réinitialisée à un autre endroit que la fin du flux. Ce bogue
a été corrigé avec la version 2.22 de la glibc.
Avec les versions de la glibc antérieures à 2.22, si l'argument mode de fmemopen()
indiquait un ajout (« a » ou « a+ »), et si l'argument taille ne couvrait pas d'octet de
valeur zéro dans tampon, alors, d'après POSIX.1-2008, la position initiale du fichier
devait être définie à l'octet qui suit la fin du tampon. Dans ce cas cependant,
l'implémentation de fmemopen() de la glibc définissait la position du fichier à -1. Ce
bogue a été corrigé avec la version 2.22 de la glibc.
Dans les versions de la glibc antérieures à 2.22, lorsqu'un appel à fseek(3) avec une
valeur de départ égale à SEEK_END était effectué sur un flux créé à l'aide de fmemopen(),
le décalage était soustrait à la position de fin de flux au lieu d'y être ajouté. Ce bogue
a été corrigé à partir de la version 2.22 de la glibc.
L'ajout du mode « binaire » dans la glibc 2.9 pour fmemopen() a modifié silencieusement
l'ABI : auparavant, fmemopen() ignorait « b » dans mode.
EXEMPLES
Le programme ci-dessous utilise fmemopen() pour ouvrir un tampon d'entrée et
open_memstream(3) pour ouvrir un tampon de sortie de taille dynamique. Ce programme scrute
la chaîne 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'
taille=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 taille;
char *ptr;
if (argc != 2) {
fprintf(stderr, "Utilisation : %s '<nombre>...'\n", argv[0]);
exit(EXIT_FAILURE);
}
in = fmemopen(argv[1], strlen(argv[1]), "r");
if (in == NULL)
handle_error("fmemopen");
out = open_memstream(&ptr, &taille);
if (out == NULL)
handle_error("open_memstream");
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("taille=%zu; ptr=%s\n", taille, ptr);
free(ptr);
exit(EXIT_SUCCESS);
}
VOIR AUSSI
fopen(3), fopencookie(3), open_memstream(3)
COLOPHON
Cette page fait partie de la publication 5.13 du projet man-pages Linux. Une description
du projet et des instructions pour signaler des anomalies et la dernière version de cette
page peuvent être trouvées à l'adresse https://www.kernel.org/doc/man-pages/.
TRADUCTION
La traduction française de cette page de manuel a été créée par Christophe Blaess
<https://www.blaess.fr/christophe/>, Stéphan Rafin <stephan.rafin@laposte.net>, Thierry
Vignaud <tvignaud@mandriva.com>, François Micaux, Alain Portal <aportal@univ-montp2.fr>,
Jean-Philippe Guérard <fevrier@tigreraye.org>, Jean-Luc Coulon (f5ibh) <jean-
luc.coulon@wanadoo.fr>, Julien Cristau <jcristau@debian.org>, Thomas Huriaux
<thomas.huriaux@gmail.com>, Nicolas François <nicolas.francois@centraliens.net>, Florentin
Duneau <fduneau@gmail.com>, Simon Paillard <simon.paillard@resel.enst-bretagne.fr>, Denis
Barbier <barbier@debian.org>, David Prévot <david@tilapin.org>, Frédéric Hantrais
<fhantrais@gmail.com> et Lucien Gentis <lucien.gentis@waika9.com>
Cette traduction est une documentation libre ; veuillez vous reporter à la GNU General
Public License version 3 ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩ concernant les
conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.
Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un
message à ⟨debian-l10n-french@lists.debian.org⟩.