Référence du fichier stdio.h

Description détaillée

Définitions et déclarations relatives aux entrées/sorties.

Macros

#define NULL

pointeur nul

#define _IOFBF

vider le tampon quand c'est nécessaire

#define _IOLBF

vider le tampon à la fin de chaque ligne

#define _IONBF

ne pas utiliser le tampon

#define BUFSIZ

taille des tampons

#define EOF

fin du fichier

#define FOPEN_MAX

nombre minimal de fichiers

#define FILENAME_MAX

taille des noms de fichier

#define L_tmpnam

taille des noms des fichiers temporaires

#define SEEK_CUR

décalage par rapport à la position actuelle

#define SEEK_END

décalage par rapport à la fin du fichier

#define SEEK_SET

décalage par rapport au début du fichier

#define TMP_MAX

nombre de fichiers temporaires

#define stderr

flux d'erreur standard

#define stdin

flux d'entrée standard

#define stdout

flux de sortie standard

Définition de type

typedef __unsigned size_t

taille des objets

typedef __FILE FILE

description des flux

typedef __fpos_t fpos_t

description de la position dans un fichier

Fonctions

int remove (const char *filename)

effacement de fichiers

int rename (const char *oldname, const char *newname)

renommage de fichiers

FILE * tmpfile (void)

fichier temporaire

char * tmpnam (char *name)

nom de fichier temporaire

int fclose (FILE *str)

fermeture de fichier

int fflush (FILE *str)

vider les tampons

FILE * fopen (const char *filename, const char *mode)

ouverture d'un fichier

FILE * freopen (const char *filename, const char *mode, FILE *str)

réouverture de fichier

void setbuf (FILE *str, char *buf)

spécifie un tampon pour le flux

int setvbuf (FILE *str, char *buf, int mode, size_t size)

contrôle la manière dont un flux utilise les tampons

int fprintf (FILE *str, const char *format,...)

écriture formatée vers un flux spécifié.

int fscanf (FILE *str, const char *format,...)

lecture formatée depuis un flux spécifié

int printf (const char *format,...)

écriture formatée vers le flux de sortie standard.

int scanf (const char *format,...)

lecture formatée depuis le flux d'entrée standard

int sprintf (char *s, const char *format,...)

écriture formatée vers une chaîne.

int sscanf (char *s, const char *format,...)

lecture formatée depuis une chaîne

int vfprintf (FILE *str, const char *format, va_list args)

écriture formatée vers un flux d'une liste d'argument donnée par une va_list.

int vprintf (const char *format, va_list args)

int vsprintf (char *s, const char *format, va_list args)

écriture formatée vers une chaîne d'une liste d'argument donnée par un va_list.

int fgetc (FILE *str)

lecture d'un caractère

char * fgets (char *s, int n, FILE *str)

lecture d'une chaîne

int fputc (int c, FILE *str)

écriture d'un caractère.

int fputs (const char *s, FILE *str)

écriture d'un chaîne.

int getc (FILE *str)

lecture d'un caractère

int getchar (void)

lecture d'un caractère depuis le flux standard d'entrée

char * gets (char *s)

lecture d'un chaîne depuis stdin

int putc (int c, FILE *str)

écriture d'un caractère.

int putchar (int c)

écriture d'un caractère sur stdout.

int puts (const char *s)

écriture d'une chaîne sur stdout.

int ungetc (int c, FILE *str)

replacement d'un caractère dans le flux

size_t fread (void *ptr, size_t eltsize, size_t nelts, FILE *str)

lecture non formatée

size_t fwrite (const void *ptr, size_t eltsize, size_t nelts, FILE *str)

écriture non formatée.

int fgetpos (FILE *str, fpos_t *pos)

récupération de la position d'un flux

int fseek (FILE *str, long offset, int whence)

changement de la position d'un flux

int fsetpos (FILE *str, const fpos_t *pos)

changement de la position d'un flux

long ftell (FILE *str)

récupération de la position d'un flux

void rewind (FILE *str)

retour à la première position d'un flux

void clearerr (FILE *str)

effacement des indicateurs d'un flux

int feof (FILE *str)

test de l'indicateur de fin de flux

int ferror (FILE *str)

test de l'indicateur d'erreur d'un flux

void perror (const char *s)

écriture d'un message d'erreur sur la sortie d'erreur standard.

Documentation des macros

#define _IOFBF

Expression constante entière indiquant, comme troisième argument à setvbuf(), que le tampon du flux peut être transmis au SE uniquement quand il est plein.

#define _IOLBF

Expression constante entière indiquant, comme troisième argument à setvbuf(), que le tampon du flux doit être transmis au SE à chaque fin de ligne.

#define _IONBF

Expression constante entière indiquant, comme troisième argument à setvbuf(), que le tampon du flux ne doit pas être utilisé.

#define BUFSIZ

Expression constante entière donnant la taille des tampons attendus par setbuf().

#define EOF

Expression constante entière négative utilisée pour indiquer une erreur. Elle est utilisée principalement, mais pas uniquement, quand l'erreur raportée est due au fait qu'il n'y a plus de données dans le flux, ce qui explique son nom (End Of File).

#define FILENAME_MAX

Expression constante entière donnant la taille d'un tableau assez grand pour contenir le plus long nom de fichier. Dans les implémentations qui n'ont pas de limite réelle, cette macro donne la taille recommandée pour les tableaux devant contenir un nom de fichier.

#define FOPEN_MAX

Expression constante entière indiquant le nombre minimal de fichiers pouvant être ouverts simultanément.

#define L_tmpnam

Expression constante entière donnant la taille d'un tableau de char assez grand pour contenir un nom de fichier temporaire généré par tmpnam().

#define NULL

Cette macro contient une constante de pointeur nul. Des valeurs populaires sont 0, (void*)0 et 0L.

Voir stddef.h pour plus d'informations.

#define SEEK_CUR

Expression constante entière indiquant, comme argument à fseek(), que le décalage se fait par rapport à la position courante du fichier.

#define SEEK_END

Expression constante entière indiquant, comme argument à fseek(), que le décalage se fait par rapport à la fin du fichier.

#define SEEK_SET

Expression constante entière indiquant, comme argument à fseek(), que le décalage se fait par rapport au début du fichier.

#define stderr

Expression de type FILE* donnant le flux d'erreur standard.

Le tampon est transmis à l'OS après chaque écriture ou à la fin de chaque ligne.

#define stdin

Expression de type FILE* donnant le flux d'entrée standard.

#define stdout

Expression de type FILE* donnant le flux de sortie standard.

Le tampon est transmis à l'OS après chaque écriture ou à la fin de chaque ligne sauf si le périphérique auquel il est connecté n'est pas interactif.

#define TMP_MAX

Expression constante entière indiquant le nombre minimum de noms de fichier uniques pouvant être générés par tmpnam().

Documentation des définition de type

typedef __FILE FILE

Les objets de ce type contiennent toute l'information nécessaire pour le contrôle des flux d'entrées/sorties, en particulier la position dans le flux, un pointeur vers un tampon, un indicateur de fin de fichier, et un indicateur d'erreur.

Un flux a aussi une orientation qui au départ est indéfinie. Après qu'une fonction d'E/S étroite a été utilisée avec le flux, son orientation devient "étroite" et seule les fonctions d'E/S étroites peuvent lui être appliquée. De même, après qu'une fonction d'E/S large a été utilisée avec le flux, son orientation devient "large" et seule les fonctions d'E/S large peuvent lui être appliquée.

Un appel réussi à freopen() rend l'orientation du flux à nouveau indéfinie. Et un appel à fwide() permet de changer l'orientation d'un flux.

Un flux large a un mbstate_t associé qui contient l'état courant nécessaire à la gestion du charset. Ce mbstate_t est stocké dans le fpos_t retourné par fgetpos() et restauré par un appel à fsetpos().

On ne manipule les variables de ce type qu'à travers des pointeurs retournés par les fonctions déclarées dans <stdio.h>.

typedef __fpos_t fpos_t

Ce type permet de stocker tout ce qui est nécessaire pour retrouver la position d'un fichier.

Ce n'est pas un type arithmétique, on peut donc uniquement récupérer la position courante d'un flux avec fgetpos() et y retourner plus tard avec fsetpos(). Il contient entre autre un mbstate_t utilisé pour les flux larges.

typedef __unsigned size_t

Ce type entier non signé est capable de contenir la taille des objets.

Voir stddef.h pour plus d'informations.

Documentation des fonctions

void clearerr ( FILE * str )

Efface les indicateurs de fin de fichier et d'erreur.

int fclose ( FILE * str )

Supprime l'association entre le flux et le fichier après avoir transféré au système d'exploitation les données restant éventuellement dans le tampon. Si le tampon a été alloué par la bibliothèque standard, il est libéré.

Retourne

0 en cas de succès, EOF en cas d'échec.

int feof ( FILE * str )

Retourne

une valeur non nulle si l'indicateur de fin de fichier du flux est mis.

int ferror ( FILE * str )

Retourne

une valeur non nulle si l'indicateur d'erreur du flux est mis.

int fflush ( FILE * str )

Transfère au système d'exploitation les données restant dans le tampon de str si str est un flux ouvert en écriture ou en mise à jour et que l'action la plus récente n'était pas une entrée. Le comportement est indéfini dans les autres cas.

Si str est un pointeur nul, effectue l'action ci-dessus pour tous les flux pour lesquels elle est définie.

Retourne

0 en cas de succès, EOF si une écriture échoue.

Note:: Cette fonction transmet le tampon au système d'exploitation, mais rien n'indique que celui-ci effecture l'opération demandée immédiatement. Si c'est nécessaire, il faut utiliser des fonctionnalités propres au SE.

int fgetc ( FILE * str )

Retourne

le caractère suivant du flux d'entrée str. Si la fin du flux est atteinte, l'indicateur de fin du flux est mis et fgetc() retourne EOF. Si une erreur de lecture a lieu, l'indicateur d'erreur du flux est mis et fgetc() retourne EOF.

int fgetpos	(	FILE *	str,
		fpos_t *	pos
	)

Stocke dans l'objet pointé par pos une description de la position courante du flux str (y compris l'état nécessaire à la gestion des charsets modaux).

Retourne

0 en cas de succès, une valeur non nulle en cas d'échec. En cas d'échec une valeur définie par l'implémentation est assignée à errno.

char* fgets	(	char *	s,
		int	n,
		FILE *	str
	)

Lit au plus n-1 caractères depuis le flux str, jusqu'à la fin du flux ou lecture d'un \n et les place dans le tableau pointé par s (y compris le \n). Un caractère nul est placé après le dernier caractère lu.

Retourne

s en cas de succès, un pointeur nul si la fin du fichier est atteinte ou si un erreur a lieu. s n'est pas modifié si la fin du fichier est atteinte avant qu'un caractère ait été lu, sinon son contenu n'est pas spécifié.

FILE* fopen	(	const char *	filename,
		const char *	mode
	)

Associe un flux avec le fichier nommé filename.

mode pointe vers un chaîne commencant par une de ces séquences de caractères (d'autres caractères peuvent suivre avec un effet dépendant de l'implémentation):

r ouvre un fichier texte en lecture.

w ouvre un fichier texte en écriture.

a ouvre un fichier texte pour l'ajout à la fin.

rb ouvre un fichier binaire en lecture.

wb ouvre un fichier binaire en écriture.

a ouvre un fichier binaire pour l'ajout à la fin.

r+ ouvre un fichier texte pour la mise à jour.

w+ ouvre ou crée un fichier texte pour la mise à jour.

a+ ouvre un fichier texte pour la mise à jour avec ajout à la fin.

r+b ou rb+ ouvre un fichier binaire pour la mise à jour.

w+b ou wb+ ouvre ou crée un fichier binaire pour la mise à jour.

a+b ou ab+ ouvre un fichier binaire pour la mise à jour avec ajout à la fin.

Pour les modes commencant par r, si le fichier n'existe pas la fonction échoue.

Pour les modes commencant par w, si le fichier existe, son contenu est effacé; si le fichier n'existe pas, il est créé.

Pour les modes commencant par a, si le fichier existe, le contenu est concervé; si le fichier n'existe pas, il est créé. Toutes les écritures ont lieu à la fin du fichier, même en présence d'appel à fseek().

Pour les modes de mise à jour (ceux dont le mode ayant servi à l'ouverture contenait +), la lecture et l'écriture sont autorisées mais entre une écriture et une lecture, il faut un appel à fflush(), fseek(), fsetpos() ou rewind() et entre une lecture et une écriture il faut avoir atteint la fin du fichier ou un appel à fseek(), fsetpos() ou rewind().

Après ouverture, le tampon est transmis à l'OS après chaque écriture ou à la fin de chaque ligne sauf si le flux est connecté à un périphérique qui n'est pas interactif. Pour changer le mode de gestion du tampon, il faut utiliser setvbuf().

Retourne

un pointeur vers le flux en cas de succès, un pointeur nul en cas d'échec.

int fprintf	(	FILE *	str,
		const char *	format,
			...
	)

Écrit les arguments qui suivent format dans le stream str sous le contrôle de de la chaîne format qui spécifie comment interpréter les arguments suivants (la plupart sont formatés). Si ceux-ci sont en nombre insuffisant ou si leur type ne correspond pas à celui demandé par format, le résultat est indéfini.

format est composée de directives commencant par % séparées par des caractères ordinaires qui sont simplement copiés vers str. Après %, dans une directive se trouvent:

éventuellement un ou plusieurs drapeaux (-, +, espace, #, 0)

éventuellement une largeur minimale de champs, un entier écrit en décimal ou un astérisque (*) qui signifie qu'elle est donnée par l'argument suivant (de type int). Si celui-ci est négatif, le comportement est le même que si un drapeau - avait été donné.

éventuellement une précision, un entier écrit en décimal ou un astérisque signifiant qu'elle est donnée par un argument entier. Si la largeur minimal et la précision sont spécifiées avec des astérisques, l'ordre des arguments est d'abord la largeur minimale, ensuite la précision. La valeur à formatter suit.

éventuellement un modificateur de format (h, l, L)

un indicateur de format (d, i, o, u, x, X, f, e, E, g, G, c, s, p, n, %)

Chaque directive indique comment formatter un argument.

Si, après avoir formaté l'argument en fonction des autres composant de la directive, le nombre de caractères nécessaires est inférieur à la largeur minimale du champs, des caractères sont ajoutés pour atteindre la largeur minimale du champs:

si le drapeau - n'a pas été donné, des espaces (ou des 0 pour les formats d, i, o, u, x, X, e, E, f, g et G si le drapeau 0 est présent et que la directive ne comporte pas de précision) sont ajoutés en début du champs

si le drapeau - a été donné, des espaces sont ajoutés en fin de champs.

La signification des autres drapeaux, de la précision et du modificateur de format dépend de l'indicateur de format.

Les indicateurs de formats sont:

d, i: l'argument, de type int (short int avec le modificateur h, long int avec le modificateur l), est écrit sous forme décimale [-]ddd. Le signe est - pour les nombres négatifs, rien, un espace (si le drapeau espace a été donné) ou un signe + (si le drapeau + a été donné) pour les nombres positifs. La précision indique le nombre minimum chiffres à utiliser, des 0 initiaux sont éventuellement ajoutés pour l'atteindre. Si une précision est spécifiée, le drapeau 0 est ignoré. La précision par défaut est 1. Aucun caractère n'est écrit si la précision est 0 et que la valeur a formatter est aussi nulle.

o, u, x, X: l'argument, de type unsigned (short unsigned avec le modificateur h, long unsigned avec le modificateur l), est écrit sous forme octale (pour o), décimale (pour u) ou hexadécimale (pour x et X, x utilisant les lettres abcdef en minuscule pour les chiffres 10 à 15, X utilisant les lettres ABCDEF). La précision (1 par défaut) indique le nombre minimum chiffres à utiliser, des 0 initiaux sont éventuellement ajoutés pour l'atteindre. Si une précision est spécifiée, le drapeau 0 est ignoré. Aucun caractère n'est écrit si la précision est 0 et que la valeur a formatter est aussi nulle.

f: l'argument de type double (long double avec le modificateur L) est écrit sous la forme [-]ddd.dddd. La précision (6 par défaut) indique le nombre de chiffres après le séparateur décimal. Si la précision est nulle et que le drapeau # n'est pas spécifié, le séparateur décimal n'est pas écrit.

e, E: l'argument de type double (long double avec le modificateur L) est écrit sous la forme $[-]d.dddd\mbox{e}\pm dd$ (le e est remplacé par E pour l'indicateur de format E). La précision (6 par défaut) indique le nombre de chiffres après le séparateur décimal. Si la précision est nulle et que le drapeau # n'est pas spécifié, le séparateur décimal n'est pas écrit. L'exposant contient au moins deux chiffres et est nul pour l'écriture de 0.

g, G: l'argument, de type double (long double avec le modificateur L), est écrit comme avec le format e (E pour G) si l'exposant aurait été inférieur à -4 ou supérieur ou égal à la précision, sinon comme avec le format f. Les zéros finaux sont supprimés, de même que le séparateur décimal si il n'aurait pas été suivit par au moins un chiffre.

c: En l'absence de modificateur l, l'argument (de type int), est converti en unsigned char et le caractère résultant est écrit. Avec le modificateur l, le résultat de la conversion est le même que celui de la conversion par ls d'un tableau de deux wchar_t, le premier étant l'argument, le deuxième un caractère large nul.

s: En l'absence de modificateur l, l'argument est de type char* et pointant dans un tableau de char; le caractère pointé et les suivants jusqu'à un caractère nul marquant la fin de chaîne sont écrits. Ce dernier caractère n'est pas écrit. Si spécifiée, la précision indique le nombre maximum de caractères à écrire. Seuls les caractères devant être écrits sont lus. En présence d'un modificateur l, l'argument est de type wchar_t* et pointe vers un tableau de wchar_t. Le contenu du tableau (jusqu'au premier caractère large nul) est converti en caractères multibytes, chaque caractère large étant converti de manière équivalent à un appel à wcrtomb(), avec l'état de conversion décrit par un objet de type mbstate_t initialisé à zéro avant la première conversion. Si spécifiée, la précision indique le nombre maximum de bytes écrits (y compris les séquences de changement d'états). Dans aucun cas, un caractère multibyte partiel n'est écrit.

p: l'argument, de type void*, est écrit sous forme d'une séquence de caractères imprimables.

n: l'argument, de type int* (long int* si le modificateur l est aussi donné, de type short int* si le modificateur h est donné), est modifié pour contenir le nombre de caractères écrits jusqu'à présent par cet appel à fprintf. Rien n'est écrit sur str.

%: un % est écrit sur str.

Retourne

le nombre de caractères écrits en case de succès, une valeur négative si une erreur a lieu.

Note:

Le format du paramètre format est similaire à celui attendu pour fscanf() mais pas parfaitement identique:

les blancs dans le format sont écrits tel quel par printf(), ils indiquent qu'il faut lire une série de caractères pour lesquels isspace() est vrai (dont les passages à la ligne) pour fscanf().

les spécificateurs d et i ont le même effet pour fprintf(), d indique que la base est 10, i indique qu'il faut découvrir la base pour fscanf().

les spécificateurs flottants sont tous traités de la même manière pour fscanf().

le modificateur de format l n'a pas d'effet pour les spécificateurs de formats flottants pour fprintf().

le spécificateur de format c permet de lire une chaîne de taille fixe (et permet de lire des espaces au contraire de s).

le spécificateur de format [ n'est pas valide pour fprintf().

* permet de spécifier une largeur de champs variable pour fprintf() et de supprimer les assignations pour fscanf().

int fputc	(	int	c,
		FILE *	str
	)

Écrit le caractère c (converti en unsigned char) dans le flux str à la position courante si possible et que str n'a pas été ouvert en mode a, ou à la fin du flux sinon.

Retourne

c en l'absence d'erreur d'écriture. EOF, en cas d'erreur d'écriture (auquel cas, l'indicateur d'erreur de str est placé).

int fputs	(	const char *	s,
		FILE *	str
	)

Écrit la chaîne pointée par s, le caractère nul final n'est pas écrit.

Retourne

un nombre non négatif en cas de succès, EOF en cas d'erreur d'écriture.

size_t fread	(	void *	ptr,
		size_t	eltsize,
		size_t	nelts,
		FILE *	str
	)

Lit dans le tableau pointé par ptr jusqu'à nelts éléments de taille eltsize. Si un élément n'est lu que partiellement, sa valeur est indéfinie.

Retourne

le nombre d'éléments lus, qui n'est inférieur à nelts que si la fin du flux est atteinte ou si une erreur de lecture a lieu.

FILE* freopen	(	const char *	filename,
		const char *	mode,
		FILE *	str
	)

Cette fonction tente de fermer str, ignorant un échec éventuel puis ouvre le fichier filename en l'associant à str.

Retourne

str en cas de succès, un pointeur nul en cas d'échec.

int fscanf	(	FILE *	str,
		const char *	format,
			...
	)

Lit les arguments qui suivent format depuis le flux str sous le contrôle de la chaîne format. Si les arguments sont en nombre insuffisant ou si leur type ne correspond pas à celui demandé par format, le résultat est indéfini.

Le format est composé de

blancs (tel que défini par isspace() dans la locale en cours), qui indiquent qu'il faut lire les caractères jusqu'à lecture d'un caractère pour lequel isspace() est faux (et qui restera à lire).

caractères ordinaires: les caractères suivant dans le flux doivent être lus et doivent correspondre aux caractères du format, sinon la lecture échoue et le premier caractère ne correspondant pas au format restera à lire.

de directives commençant par %.

Après %, dans une directive se trouvent:

éventuellement un * indiquant que la lecture doit être faite mais le résultat ne doit pas être assigné dans le paramètre suivant;

éventuellement une largeur maximale de champs

éventuellement un modificateur de format (h, l, L)

un indicateur de format (d, i, o, u, x, X, f, e, E, g, G, c, s, p, n, %, [)

Les indicateurs de format ont la signification suivante:

d: lecture d'un int (short int pour hd, long int pour ld) ayant le format attendu pour un appel à strtol() pour lequel l'argument base reçoit 10.

i: lecture d'un int (short int pour hi, long int pour li) ayant le format attendu pour un appel à strtol() pour lequel l'argument base reçoit 0.

o: lecture d'un int (short int pour ho, long int pour lo) ayant le format attendu pour un appel à strtol() pour lequel l'argument base reçoit 8.

x, X: lecture d'un int (short int pour hx, hX, long int pour lx, lX) ayant le format attendu pour un appel à strtol() pour lequel l'argument base reçoit 16.

e, E, f, g, G: lecture d'un float (double pour le, lE, lf, lg, lG, long double pour Le, LE, lf, lg, LG) ayant le format attendu pour un appel à strtod().

s: lecture d'une séquence de caractères non blancs. En l'absence du modificateur l, l'argument correspondant est un pointeur vers un tableau de caractères assez large pour contenir la séquence de caractères et un caractère nul final qui est ajouté. En présence d'un modificateur l, l'argument correspondant est un pointeur vers un tableau de wchar_t assez large pour contenir la séquence de caractères larges et un caractère large nul final qui est ajouté. La séquence de caractères larges est obtenue en convertissant les caractères optenus dans le flux, comme par un appel à mbrtowc() avec un mbstate_t initialisé à 0 pour le premier appel.

c: lecture d'une séquence de caractères en nombre équal à la largeur maximale du champs (1 par défaut). Sans modificateur l, le paramètre correspondant est un pointeur vers un tableau de caractères assez large pour contenir la séquence. En présence d'un modificateur l, le paramètre correspondant est un pointeur vers un tableau de wchar_t assez large pour contenir la séquence. Celle-ci est optenue en convertissant les caractères obtenus dans le flux comme par un appel à mbrtowc() avec un mbstate_t intialisé à 0 pour le premier appel.

[: lecture d'une séquence non vide de caractères (à laquelle un nul final sera ajouté). Les caractères valides sont ceux compris entre le [ et un ] finissant la spécification. Si un ^ est en premier caractère après le [ initial, l'ensemble désigne les caractères non valides. Un ] peut être mis dans l'ensemble des caractères valides en le mettant en premier caractère après un ^ éventuel. Le comportement est indéfini si un - est présent ailleurs qu'en premier caractère après un ^ éventuel ou en dernier caractère avant le ] final. eur vers un tableau de caractères assez large pour contenir la séquence de caractères et un caractère nul final qui est ajouté. En présence d'un modificateur l, l'argument correspondant est un pointeur vers un tableau de wchar_t assez large pour contenir la séquence de caractères larges et un caractère large nul final qui est ajouté. La séquence de caractères larges est obtenue en convertissant les caractères optenus dans le flux, comme par un appel à mbrtowc() avec un mbstate_t initialisé à 0 pour le premier appel.

p: lecture d'un void* avec un format correspondant à celui écrit par le format p de printf().

n: écriture dans un int (short int pour hn, long int pour ln) du nombre de caractères lus. L'exécution de cette directive n'augmentent pas le nombre d'assignement retourné par fscanf().

%: lecture d'un %.

Retourne

le nombre d'éléments assignés, ce qui peut être moins que le nombre d'assignation demandé ou EOF en cas d'échec avant la première assignation.

Note:: Voir sscanf() pour des exemples.
Voir fprintf() pour un résumé des différences de format entre fscanf() et fprintf().

int fseek	(	FILE *	str,
		long	offset,
		int	whence
	)

Change la position du flux str relativement au début du fichier (si whence vaut SEEK_SET), à la position actuelle (si whence vaut SEEK_CUR) ou à la fin du fichier (si whence vaut SEEK_END) de manière décrite par offset.

Pour les flux de texte (ouverts avec un mode sans b), soit offset est nul, soit offset est une valeur retournée par un appel réussi à ftell() et whence est SEEK_SET.

Pour les flux binaires (ouverts avec un mode contenant un b), la position relative est de offset caractères. La valeur SEEK_END de whence ne doit pas obligatoirement est supportée.

Un appel réussi efface l'indicateur de fin de fichier.

Retourne

0 en cas de succès, une valeur non nulle si la requête n'a pu être satisfaite.

int fsetpos	(	FILE *	str,
		const fpos_t *	pos
	)

Replace la position du flux str (y compris l'état nécessaire à la gestion des charsets modaux) à celle qu'elle était lors de l'appel à fgetpos() ayant initialisé pos.

Un appel réussi efface l'indicateur de fin de fichier.

Retourne

0 en cas de succès, une valeur non nulle en cas d'échec. En cas d'échec une valeur définie par l'implémentation est assignée à errno.

long ftell ( FILE * str )

Pour les flux binaires (ceux ouverts avec un mode contenant un b), la position dans le flux est le nombre de caractères depuis le début du flux.

Pour les flux textes, la valeur n'est pas spécifiée et permet à fseek() de revenir à la position courante. La différence entre deux résultats de ftell() n'a pas nécessairement un rapport avec le nombre de caractères séparant les deux positions.

Retourne

la position dans le flux en cas de succès, -1 en cas d'échec. En cas d'échec, une valeur définie par l'implémentation est assignée à errno.

size_t fwrite	(	const void *	ptr,
		size_t	eltsize,
		size_t	nelts,
		FILE *	str
	)

Écrit, depuis le tableau pointé par ptr, jusqu'à nelts éléments de taille eltsize.

Retourne

le nombre d'éléments écrit, qui n'est inférieur à nelts que si une erreur d'écriture a lieu.

int getc ( FILE * str )

Équivalent à fgetc(str) mais peut évaluer son argument plusieurs fois si elle est implémentée comme une macro.

Retourne

le caractère suivant du flux d'entrée str. Si la fin du flux est atteinte, l'indicateur de fin du flux est mis et getc() retourne EOF. Si une erreur de lecture a lieu, l'indicateur d'erreur du flux est mis et getc() retourne EOF.

int getchar ( void )

Équivalent à fetc(stdin).

Retourne

le caractère suivant de stdin. Si la fin du flux est atteinte, l'indicateur de fin de stdin est mis et getchar() retourne EOF. Si une erreur de lecture a lieu, l'indicateur d'erreur de stdin est mis et getchar() retourne EOF.

char* gets ( char * s )

Lit des caractères depuis stdin, jusqu'à la fin du flux ou lecture d'un \n et les place dans le tableau pointé par s (sauf le \n). Un caractère nul est placé après le dernier caractère lu.

Retourne

s en cas de succès, un pointeur nul si la fin du fichier est atteinte ou si un erreur a lieu. s n'est pas modifié si la fin du fichier est atteinte avant qu'un caractère ait été lu, sinon son contenu n'est pas spécifié.

Note:: L'absence de contrôle du nombre de caractères lus doit faire préférer fgets() à gets().

void perror ( const char * s )

Écrit sur la sortie d'erreur standard la chaîne pointée par s si s n'est pas un pointeur nul, un deux-point (:), un espace et la chaîne qu'aurait retourné strerr(errno) au moment de l'appel. Cette chaîne décrit de manière définie par l'implémentation et dépendante des locales l'erreur indiquée par errno.

int printf	(	const char *	format,
			...
	)

Équivalent à fprintf() avec stdout comme premier argument.

Retourne

le nombre de caractères écrits en case de succès, une valeur négative si une erreur a lieu.

int putc	(	int	c,
		FILE *	str
	)

Équivalent à fputc(c, str) mais peut évaluer son argument plusieurs fois si elle est implémentée comme une macro.

Retourne

c en l'absence d'erreur d'écriture. EOF, en cas d'erreur d'écriture (auquel cas, l'indicateur d'erreur de str est placé).

int putchar ( int c )

Équivalent à putc(c, stdout).

int puts ( const char * s )

Écrit la chaîne pointée par s sur stdout (sans le caractère nul final) et ajoute un
à la sortie.

Retourne

une valeur non négative en l'absence d'erreur, sinon EOF.

int remove ( const char * filename )

Efface le fichier filename de sorte qu'une tentative ultérieure pour l'ouvrir échoue sauf s'il a été créé à nouveau depuis.

Le comportement est indéfini si le fichier est ouvert.

Retourne

0 en cas de succès, une valeur non nulle en cas d'échec.

int rename	(	const char *	oldname,
		const char *	newname
	)

Renomme le fichier oldname en newname.

Si newname existe déjà, le comportement est spécifié par l'implémentation.

Retourne

0 en cas de succès, une valeur non nulle en cas d'échec. En cas d'échec, le fichier s'il existe reste accessible par oldname.

void rewind ( FILE * str )

Replace le flux au début du fichier et efface les indicateurs de fin de fichier et d'erreur.

int scanf	(	const char *	format,
			...
	)

Équivalent à fscanf() avec stdin comme premier argument.

void setbuf	(	FILE *	str,
		char *	buf
	)

Indique que le flux str doit utiliser buf comme tampon. buf doit être soit nul, auquel cas le flux devient sans tampon, soit pointer vers un tableau de BUFSIZ char.

À part la valeur du résultat, cette fonction est équivalente à

setvbuf(str, buf, (buf == 0 ? _IONBF : _IOFBF), BUFSIZ);

Cette fonction rends à nouveau indéfinie l'orientation du flux.

int setvbuf	(	FILE *	str,
		char *	buf,
		int	mode,
		size_t	size
	)

Indique que le flux str doit utiliser un tableau de size char comme tampon. Si buf est un pointeur nul, le tampon est alloué par setvbuf(), sinon le tableau pointé par buf est utilisé.

mode indique de quelle manière le tampon est utilisé:

_IONBF: le tampon n'est pas utilisé

_IOLBF: le tampon est transmis au système d'exploitation à la fin de chaque ligne

_IOFBF: le tampon est transmis au système d'exploitation quand il est plein

Cette fonction doit être appelée sur un fichier ouvert et avant tout autre opération.

Retourne

0 en cas de succès ou une valeur non nulle si la valeur de mode n'est pas valide ou si la requête ne peut être honorée.

Note:: Quand on spécifie un tampon, il faut s'assurer qu'il reste valable jusqu'à fermeture du flux.

int sprintf	(	char *	s,
		const char *	format,
			...
	)

Équivalent à fprintf() mais les caractères écrits sont placés dans le tableau pointé par s plutôt qu'envoyé vers un flux. Un caractère nul est placé après les caractères générés.

Avertissement:: Il n'y a aucun contrôle sur le nombre de caractères écrits dans le tableau pointé par s.
Le comportement est indéfini s'il faut copier entre des objets qui se recouvrent.

Retourne

le nombre de caractères écrits en case de succès, une valeur négative si une erreur a lieu.

int sscanf	(	char *	s,
		const char *	format,
			...
	)

Cette fonction est semblable à fscanf() à part qu'elle prend les caractères successifs de s plutôt que d'un flux, un '\0' étant équivalent à la fin du fichier pour fscanf(). Si l'utilisation de cette fonction demande une copie entre des objets qui se recouvrent, le comportement est indéfini.

Retourne

le nombre d'éléments assignés, ce qui peut être moins que le nombre d'assignation demandé ou EOF en cas d'échec avant la première assignation.

sscanf("  ", " x");

retourne EOF parce que la fin de la chaîne est atteinte sans qu'il y ait d'assignation.

sscanf(" 45 ", " %*d foo");

retourne EOF parce que la fin de la chaîne est atteinte sans qu'il y ait d'assignation même s'il y a une conversion.

sscanf("  x ", " x");

retourne 0 parce que la fin de la chaîne n'est pas atteinte et qu'il n'y a pas d'assignation.

sscanf(" 45 ", " %*d");

retourne 0 parce que la fin de la chaîne n'est atteinte et qu'il n'y a pas d'assignation même s'il y a une conversion.

sscanf(" 45 ", " %d", &i);

retourne 1 parce qu'il y a eu une assignation

sscanf(" 45 ", " %d %d", &i, &j);

retourne 1 parce qu'il y a eu une assignation même si toutes celles qui ont été demandées n'ont pas eu lieu.

FILE* tmpfile ( void )

Crée un fichier temporaire, qui sera effacé automatiquement lors de la fermeture du fichier ou à la fin du programme. Le flux se comporte comme si le fichier était ouvert en mode "wb+" (voir fopen()).

Retourne

un pointeur vers le flux créé en cas de succès, un pointeur nul en cas d'échec.

Note:: En cas de fin anormale du programme, le fait que le fichier temporaire soit effacé ou non est spécifié par l'implémentation.

char* tmpnam ( char * name )

Génère un nom valide de fichier qui n'est pas le nom d'un fichier existant. La fonction génère un nom différent à chaque fois et peut être appelée au moins TMP_MAX fois.

Si name est un pointeur nul, le nom est généré dans un tampon interne dont l'adresse est retournée. Un appel ultérieur à tmpnam() peut utiliser le même tampon, il faut donc le copier si la valeur doit être conservée. L'implémentation doit se comporter comme si aucune autre fonction de la bibliothèque n'appelle tmpnam().

Si name est non nul, c'est un pointeur vers un tableau d'au moins L_tmpnam caractères dans lequel la fonction écrira son résultat.

Retourne

name s'il est non nul, un pointeur vers le tampon interne utilisé sinon.

int ungetc	(	int	c,
		FILE *	str
	)

Replace le caractère c dans le flux d'entrée str. Les caractères ainsi replacé seront lus par les fonctions d'entrée dans l'ordre inverse dans lequel ils ont été replacés. La norme n'impose pas à l'implémentation de permettre de pouvoir replacer ainsi plus d'un caractère.

Un appel à une fonction de déplacement (ftell(), fsetpos(), rewind()) fait oublier tous les caractères replacés sur le flux.

Un appel réussi à ungetc() efface l'indicateur de fin du flux.

Après un appel réussi à ungetc(), la position des flux texte est indéfinie, celle des flux binaires est décrémentée si elle n'était pas nulle.

Retourne

c si l'opération réussi, EOF sinon.

int vfprintf	(	FILE *	str,
		const char *	format,
		va_list	args
	)

Équivalent à fprintf() mais en utilisant les arguments décrits par une va_list. args doit avoir été initialisé par un va_start. vfprintf() n'appelle pas va_end, donc cet appel doit être fait par l'appelant après le retour de vfprintf().

Retourne

le nombre de caractères écrits en case de succès, une valeur négative si une erreur a lieu.

int vprintf	(	const char *	format,
		va_list	args
	)

int vsprintf	(	char *	s,
		const char *	format,
		va_list	args
	)

Équivalent à sprintf() mais en utilisant les arguments décrits par une va_list. args doit avoir été initialisé par un va_start. vsprintf() n'appelle pas va_end, donc cet appel doit être fait par l'appelant après le retour de vsprintf().

Retourne

le nombre de caractères écrits en case de succès, une valeur négative si une erreur a lieu.


Macros
#define	NULL
	pointeur nul
#define	_IOFBF
	vider le tampon quand c'est nécessaire
#define	_IOLBF
	vider le tampon à la fin de chaque ligne
#define	_IONBF
	ne pas utiliser le tampon
#define	BUFSIZ
	taille des tampons
#define	EOF
	fin du fichier
#define	FOPEN_MAX
	nombre minimal de fichiers
#define	FILENAME_MAX
	taille des noms de fichier
#define	L_tmpnam
	taille des noms des fichiers temporaires
#define	SEEK_CUR
	décalage par rapport à la position actuelle
#define	SEEK_END
	décalage par rapport à la fin du fichier
#define	SEEK_SET
	décalage par rapport au début du fichier
#define	TMP_MAX
	nombre de fichiers temporaires
#define	stderr
	flux d'erreur standard
#define	stdin
	flux d'entrée standard
#define	stdout
	flux de sortie standard
Définition de type
typedef __unsigned	size_t
	taille des objets
typedef __FILE	FILE
	description des flux
typedef __fpos_t	fpos_t
	description de la position dans un fichier
Fonctions
int	remove (const char *filename)
	effacement de fichiers
int	rename (const char oldname, const char newname)
	renommage de fichiers
FILE *	tmpfile (void)
	fichier temporaire
char *	tmpnam (char *name)
	nom de fichier temporaire
int	fclose (FILE *str)
	fermeture de fichier
int	fflush (FILE *str)
	vider les tampons
FILE *	fopen (const char filename, const char mode)
	ouverture d'un fichier
FILE *	freopen (const char filename, const char mode, FILE *str)
	réouverture de fichier
void	setbuf (FILE str, char buf)
	spécifie un tampon pour le flux
int	setvbuf (FILE str, char buf, int mode, size_t size)
	contrôle la manière dont un flux utilise les tampons
int	fprintf (FILE str, const char format,...)
	écriture formatée vers un flux spécifié.
int	fscanf (FILE str, const char format,...)
	lecture formatée depuis un flux spécifié
int	printf (const char *format,...)
	écriture formatée vers le flux de sortie standard.
int	scanf (const char *format,...)
	lecture formatée depuis le flux d'entrée standard
int	sprintf (char s, const char format,...)
	écriture formatée vers une chaîne.
int	sscanf (char s, const char format,...)
	lecture formatée depuis une chaîne
int	vfprintf (FILE str, const char format, va_list args)
	écriture formatée vers un flux d'une liste d'argument donnée par une va_list.
int	vprintf (const char *format, va_list args)
int	vsprintf (char s, const char format, va_list args)
	écriture formatée vers une chaîne d'une liste d'argument donnée par un va_list.
int	fgetc (FILE *str)
	lecture d'un caractère
char *	fgets (char s, int n, FILE str)
	lecture d'une chaîne
int	fputc (int c, FILE *str)
	écriture d'un caractère.
int	fputs (const char s, FILE str)
	écriture d'un chaîne.
int	getc (FILE *str)
	lecture d'un caractère
int	getchar (void)
	lecture d'un caractère depuis le flux standard d'entrée
char *	gets (char *s)
	lecture d'un chaîne depuis stdin
int	putc (int c, FILE *str)
	écriture d'un caractère.
int	putchar (int c)
	écriture d'un caractère sur stdout.
int	puts (const char *s)
	écriture d'une chaîne sur stdout.
int	ungetc (int c, FILE *str)
	replacement d'un caractère dans le flux
size_t	fread (void ptr, size_t eltsize, size_t nelts, FILE str)
	lecture non formatée
size_t	fwrite (const void ptr, size_t eltsize, size_t nelts, FILE str)
	écriture non formatée.
int	fgetpos (FILE str, fpos_t pos)
	récupération de la position d'un flux
int	fseek (FILE *str, long offset, int whence)
	changement de la position d'un flux
int	fsetpos (FILE str, const fpos_t pos)
	changement de la position d'un flux
long	ftell (FILE *str)
	récupération de la position d'un flux
void	rewind (FILE *str)
	retour à la première position d'un flux
void	clearerr (FILE *str)
	effacement des indicateurs d'un flux
int	feof (FILE *str)
	test de l'indicateur de fin de flux
int	ferror (FILE *str)
	test de l'indicateur d'erreur d'un flux
void	perror (const char *s)
	écriture d'un message d'erreur sur la sortie d'erreur standard.