Provided by: manpages-fr-dev_4.27.0-1_all 
NOM
fmemopen - Ouvrir de la mémoire en tant que flux
BIBLIOTHÈQUE
Bibliothèque C standard (libc, -lc)
SYNOPSIS
#include <stdio.h>
FILE *fmemopen(void tampon[.taille], 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 glibc 2.10 :
_POSIX_C_SOURCE >= 200809L
Avant la glibc 2.10 :
_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.
ATTRIBUTS
Pour une explication des termes utilisés dans cette section, consulter attributes(7).
┌──────────────────────────────────────────────────────────────────────┬──────────────────────┬─────────┐
│ Interface │ Attribut │ Valeur │
├──────────────────────────────────────────────────────────────────────┼──────────────────────┼─────────┤
│ fmemopen(), │ Sécurité des threads │ MT-Safe │
└──────────────────────────────────────────────────────────────────────┴──────────────────────┴─────────┘
STANDARDS
POSIX.1-2008.
HISTORIQUE
glibc 1.0.x. POSIX.1-2008.
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 ».
Avec la glibc 2.22, le mode binaire a été supprimé (voir ci-dessous), de nombreux bogues anciens dans
l'implémentation de fmemopen() ont été résolus et un nouveau symbole versionné a été créé pour cette
interface.
Mode binaire
De la glibc 2.9 à la glibc 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) est relative à la fin du tampon (c'est-à-dire 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.
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).
BOGUES
Avant la glibc 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 glibc 2.22.
Avant la glibc 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 glibc 2.22.
Avant la glibc 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 glibc 2.22.
Avant la glibc 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 glibc 2.22.
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 <err.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int
main(int argc, char *argv[])
{
FILE *out, *in;
int v, s;
size_t taille;
char *ptr;
if (argc != 2) {
fprintf(stderr, "Utilisation : %s '<num>...'\n", argv[0]);
exit(EXIT_FAILURE);
}
in = fmemopen(argv[1], strlen(argv[1]), "r");
if (in == NULL)
err(EXIT_FAILURE, "fmemopen");
out = open_memstream(&ptr, taille);
if (out == NULL)
err(EXIT_FAILURE, "open_memstream");
for (;;) {
s = fscanf(in, "%d", &v);
if (s <= 0)
break;
s = fprintf(out, "%d ", v * v);
if (s == -1)
err(EXIT_FAILURE, "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)
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 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.
Pages du manuel de Linux 6.9.1 15 juin 2024 fmemopen(3)