Le langage C

Les flots sont représentés dans les programmes par des variables de type FILE *. La structure FILE est définie dans le fichier <stdio.h>. Pour utiliser un ou plusieurs flots il faut donc écrire en tête de son programme la directive

#include <stdio.h>

puis une déclaration de la forme

FILE *fichier;

Un fichier est donc représenté en C par une variable d'un type pointeur. Par conséquent, sa déclaration n'autorise aucune des opérations propres aux fichiers, aussi longtemps qu'on n'aura pas fait le nécessaire (voyez la fonction fopen ci-après) pour qu'il pointe sur une structure légitimement allouée et qui constitue la description d'un fichier ouvert.

Parmi les principales fonctions qui effectuent les opérations générales (ouverture, fermeture, etc.) sur les flots nous avons :

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

Cette fonction ouvre le fichier dont le nom est indiqué par la chaine nom et rend un pointeur sur le flot correspondant, ou NULL si l'opération a échoué (fichier absent, etc.). Le nom doit être correct pour le système d'exploitation sous-jacent ; cela ne regarde pas le langage C.

Les valeurs permises pour mode sont :

• "r" (read) ouverture d'un fichier. Le fichier doit exister ; son contenu n'est pas détruit. Le descripteur du flot créé est positionné en lecture et au début du fichier. En principe, seules les opérations de lecture sont permises sur ce flot
• "r+" comme "r", mais les opérations d'écriture sont permises aussi
• "w" (write) création d'un fichier. Le fichier peut exister ou non ; s'il existe, son contenu est entièrement effacé. Le descripteur du flot créé est positionné en écriture et au début du fichier (qui est vide). En principe, seules les opérations d'écriture sont permises sur ce flot
• "w+" comme "w", mais les opérations de lecture sont permises aussi
• "a" (append) allongement d'un fichier. Le fichier existe ou non ; s'il existe, son contenu n'est pas effacé. Le descripteur du flot créé est positionné en écriture et à la fin du fichier. Seules les opérations d'écriture sont permises
• "a+" comme "a", mais les opérations de lecture sont permises aussi
• "rb", "r+b", "wb", "w+b", "ab", "a+b" : si on envisage d'utiliser le fichier en mode binaire il faut ajouter la lettre b au mode ("r+b", "w+b" et "a+b" peuvent se noter aussi "rb+", "wb+" et "ab+")

Remarque 1. La seule différence que la lettre b dans le mode introduit dans le fonctionnement de toutes les fonctions d'entrée-sortie est la suivante : si le fichier est « de texte » (i.e. si la lettre b ne figure pas dans le mode) alors :

• en lecture, chaque occurrence d'une marque de fin de ligne est détectée et, si cette marque n'est pas le caractère '\n' lui-même, remplacée par l'unique caractère '\n',
• toute demande d'écriture du caractère '\n' produit en fait l'envoi effectif au fichier de la marque de fin de ligne requise par le système sous-jacent.

Il n'est donc pas exclu que sur un système d'exploitation donné l'ajout de la lettre b au mode soit sans effet. C'est notamment le cas d'UNIX, ou les fins de ligne sont indiquées par le caractère '\n'.

Remarque 2. Sur l'intérêt qu'il peut y avoir à effectuer des lectures et des écritures sur le même fichier, voir les remarques faites à la section 7.4.3 à propos des fichiers en accès relatif.

int fflush(FILE *flot)

Dans le cas d'un flot de sortie, cette fonction provoque l'écriture « physique » immédiate du tampon en cours de remplissage. Elle rend EOF en cas d'erreur, zéro dans les autres cas.

D'après la norme officielle du langage C, l'effet de fflush sur un flot qui n'est pas un flot de sortie est indéfini. Mais pour la plupart des bibliothèques actuelles, l'appel de cette fonction sur un flot d'entrée supprime les caractères disponibles dans le tampon. Par exemple, dans le cas fréquent ou l'entrée standard correspond au clavier, l'appel fflush(stdin) fait disparaitre tous les caractères déjà tapés mais pas encore lus par le programme.

Remarque. Si le fichier physique qui correspond au flot indiqué est un organe interactif, par exemple l'écran d'un poste de travail, alors la fonction fflush est implicitement appelée dans deux circonstances très fréquentes :

• l'écriture du caractère '\n' qui produit l'émission d'une marque de fin de ligne et la vidange effective du tampon,
• le début d'une opération de lecture sur l'unité d'entrée associée (les organes d'entrée-sortie interactifs forment généralement des couples) ; ainsi, par exemple, une lecture au clavier provoque la vidange du tampon d'écriture à l'écran. Cela permet qu'une question soit effectivement affichée avant que l'utilisateur ne doive taper la réponse correspondante.

int fclose(FILE *flot)

Cette fonction ferme le flot indiqué, produisant l'écriture physique des tampons, la restitution de l'espace alloué pour le tampon et les descripteurs du flot, etc. Elle rend zéro en cas de succès, une autre valeur en cas d'erreur.

A la suite d'un appel comme fclose(flot) l'emploi de la variable flot est illégitime. Oublier de fermer, par un appel de fclose, un fichier qui a été ouvert en lecture n'est en général pas une erreur importante. Mais oublier de fermer un fichier qui a été ouvert en écriture (c'est-à-dire un fichier qui vient d'être créé) peut être fatal pour l'information qui y a été écrite, car

• le contenu du tampon d'écriture en cours de formation lors de la terminaison du programme ne sera probablement pas sauvegardé dans le fichier ;
• dans certains systèmes, les fichiers nouvellement créés ne subissent les opérations qui les rendent connus du système d'exploitation (comme l'inclusion de leur nom dans un répertoire) qu'au moment de leur fermeture. Un fichier qui n'a jamais été fermé a donc une existence très précaire.

int feof(FILE *flot)

Cette fonction n'a d'intérêt que si flot désigne un fichier en lecture. Elle renvoie une valeur non nulle si et seulement si l'indicateur de fin de fichier du flot indiqué est vrai. Cela se produit non pas lorsque le fichier est positionné sur sa fin mais lorsqu'il est placé au-delà de sa fin.

Autrement dit, feof(fic) devient vrai immédiatement après qu'une lecture sur fic ait échoué parce qu'il n'y avait plus [assez] d'informations dans fic pour la satisfaire.

En particulier, feof n'est jamais vrai après l'ouverture (en lecture) du fichier, même lorsque ce dernier est vide. Il faut au moins une [tentative de] lecture pour, éventuellement, le rendre vrai.

Cette spécification de la fonction feof fonde le schéma suivant, de lecture séquentielle d'un fichier :

FILE *fichier;
...
fichier = fopen(nom, "rb");
/* vérification du succès de l'ouverture de fichier */
...
/* lecture de données sur fichier */
while ( ! feof(fichier)) {
	traitement des données lues
	lecture de données sur fichier
}
...
int ferror(FILE *flot)

Cette fonction renvoie une valeur non nulle si et seulement si l'indicateur d'erreur du flot indiqué est « vrai ». Elle doit être appelée immédiatement après une entrée-sortie sur ce flot pour savoir si l'opération en question a échoué. La variable globale entière errno (déclarée dans <errno.h>) contient alors un code renseignant sur la nature de l'erreur.

FILE *tmpfile(void)

Cette fonction crée un fichier temporaire en mode "w+b", sans nom externe, qui sera automatiquement détruit à la terminaison du programme. Elle renvoie le flot associé ou NULL en cas d'erreur.

int setvbuf(FILE *flot, char *tampon, int mode, size t taille)

Cette fonction redéfinit le tampon associé à un flot ouvert. Elle doit être appelée après l'ouverture du flot mais avant toute lecture ou écriture. L'argument mode doit être une des trois constantes suivantes, définies dans <stdio.h> :

• IOFBF Tampon de taille fixe. L'écriture ou la lecture physique a lieu lorsque le tampon contient taille caractères.
• IOLBF Tampon égal à une ligne. L'écriture ou la lecture physique a lieu lors de la rencontre du caractère 'nn' qui détermine la fin des lignes.
• IONBF Pas de tampon. Une écriture ou une lecture physique a lieu à chaque lecture ou écriture logique. L'argument taille indique la taille voulue pour le tampon. L'argument tampon, s'il n'est pas NULL, est censé pointer un espace (de taille au moins égale à taille) qui sera utilisé comme tampon. Si tampon est NULL, alors la fonction alloue un espace propre.

Sans que le programmeur n'ait à prendre aucune disposition particulière, l'exécution d'un programme commence avec trois flots de texte automatiquement ouverts par le système. Ils sont connectés (on dit affectés) aux organes d'entrée-sortie les plus « naturels » par rapport à la manière dont on utilise l'ordinateur. Ces fichiers sont déclarés dans <stdio.h>, de la manière suivante :

FILE *stdin, *stdout, *stderr;

• stdin est l'unité standard d'entrée. Elle est habituellement affectée au clavier du poste de travail
• stdout est l'unité standard de sortie. Elle est habituellement affectée à l'écran du poste de travail
• stderr est l'unité standard d'affichage des erreurs. Elle est aussi affectée à l'écran du poste de travail

Les fonctions de lecture (resp. d'écriture) qui ne spécifient pas un autre flot utilisent stdin (resp. stdout).

Remarque. L'utilisation des unités standard apparait encore plus intéressante lorsque l'on sait que dans UNIX et plusieurs autres systèmes d'exploitation il est permis de réaffecter les unités standard lors d'une exécution du programme, sans qu'il faille recompiler ce dernier. En UNIX et MS-DOS cela fonctionne de la manière suivante : supposons que prog1 soit un programme qui n'utilise que les unités standard stdin et stdout. Activé par la commande prog1, il lira ses données au clavier et affichera ses résultats à l'écran. Mais s'il est lancé par la commande

prog1 < fichier1 (resp. : prog1 > fichier2)

alors le fichier fichier1 (resp. fichier2) remplacera le clavier (resp. l'écran). De manière similaire, supposons que prog2 soit un autre programme qui fait ses entrées-sorties de la même manière. Alors la commande

prog1 | prog2

active en parallèle ces deux programmes avec la sortie standard de prog1 connectée à l'entrée standard de prog2 (les sorties de prog1 sont lues et exploitées par prog2 au fur et à mesure qu'elles sont produites par prog1). Bien entendu, tout cela se combine. Par exemple, la commande

prog1 < fichier1 	| prog2 > fichier2

active prog1 et prog2. Les données de prog1 sont lues dans fichier1, ses résultats sont fournis à titre de données à prog2, dont les résultats sont écrits dans fichier2.

Les fonctions de lecture-écriture les plus simples effectuent la lecture ou l'écriture d'un caractère isolé ou bien la lecture ou l'écriture d'une ligne. Pour la lecture nous avons :

int fgetc(FILE *flot)

Renvoie le caractère suivant sur le flot indiqué, ou EOF si la fin du fichier est atteinte ou si une erreur survient. C'est une vraie fonction.

int getc(FILE *flot)

Fait la même chose que fgetc mais c'est peut être macro.

L'intérêt d'utiliser une macro réside dans l'efficacité supérieure des (petites) macros par rapport aux (petites) fonctions 56. Il ne faut pas oublier cependant qu'il y a deux cas ou les macros ne peuvent pas être utilisées :

• lorsque l'argument a un effet de bord. Une expression comme
   

  Sélectionnez

  *s++ = fgetc(table_de_fichiers[i++])

  est correcte (mais peu utilisée), tandis que

   

  Sélectionnez

  *s++ = getc(table_de_fichiers[i++])

  est certainement erronée, car ayant un effet indéfini (on ne peut pas dire combien de fois i sera incrémenté) ;

• lorsqu'il faut obtenir l'adresse de l'opération en question, pour la passer comme argument d'une autre fonction. Par exemple, si getc est une macro, un appel comme appliquer(getc, fichier) sera certainement trouvé incorrect par le compilateur.
   

  Sélectionnez

  int getchar(void)
  getchar() équivaut à getc(stdin) ;
  char *fgets(char *s, int n, FILE *flot)

  Lecture d'une ligne en veillant à ne pas déborder. Plus précisément, cette fonction lit des caractères sur le flot indiqué et les place dans l'espace pointé par s. Elle s'arrête lorsqu'elle a lu n¡1 caractères ou lorsqu'elle a rencontré un caractère 'nn' de fin de ligne (ce caractère est copié dans le tableau). Un caractère 'n0' est ajouté à la fin du tableau. La fonction rend s, ou NULL si une erreur ou la fin du fichier a été rencontrée.

  Lisez aussi la remarque faite ci-après à propos de la fonction gets.

   

  Sélectionnez

  char *gets(char *s)

  Lecture d'une ligne sur le flot stdin. Les caractères lus sont rangés dans l'espace pointé par s. Elle renvoie le même résultat que fgets mais, contrairement à cette dernière

• il n'y a pas de test de débordement 57 ;
• le caractère de fin de ligne est remplacé par 'n0'.

  Attention. L'argument de gets doit être l'adresse d'un espace disponible (accessible en écriture) et de taille suffisante, dans lequel gets puisse ranger les caractères qui seront lus.

Exemples. Pour illustrer ces fonctions, voici deux exercices d'école. D'une part, l'écriture d'une fonction analogue à gets en utilisant getchar :

char *myGets(char *s) {
int c, i = 0;
c = getchar();
 
while (c != '\n') {
	if (c == EOF)
		return NULL;
	s[i++] = c;
	c = getchar();
}
s[i] = '\0';
return s;
}

D'autre part, l'écriture d'une fonction analogue à getchar (version fonction) en utilisant gets :

int myGetchar(void) {
	static char tampon[256] = "";
	static char *pos = tampon;
	if (*pos == 0) {
		if (gets(tampon) == NULL)
			return EOF;
		strcat(tampon, "\n");
		pos = tampon;
	}
	return *pos++;
}

Voyons maintenant les fonctions d'écriture :

int fputc(int caractere, FILE *flot)

écrit le caractere indiqué sur le flot indiqué. Renvoie le caractère écrit ou EOF si une erreur survient.

C'est une vraie fonction.

int putc(int caractere, FILE *flot)

Fait la même chose que fputc mais peut être une macro. Voir à ce propos les remarques faites à l'occasion de l'introduction de getc.

int putchar(int caractere)
putchar(c) équivaut à putc(c, stdout).
int fputs(const char *s, FILE *flot)

écrit la chaine s sur le flot indiqué. La fonction renvoie EOF en cas d'erreur, une valeur ¸ 0 dans les autres cas.

int puts(const char *s)

Cette fonction écrit la chaine s sur le flot stdout. Elle renvoie le même résultat que fputs. Contrairement à fputs un caractère 'nn' est ajouté à la suite de la chaine.

int ungetc(int c, FILE *flot)

« Délecture » du caractère c. Cette fonction remet le caractère c dans le flot indiqué, ou il sera trouvé lors de la prochaine lecture. Sur chaque flot, seule la place pour un caractère « délu » est garantie. On ne peut pas « délire » le caractère EOF.

Cette opération incarne donc l'idée de restitution (à l'unité d'entrée, qui en est le fournisseur) d'un caractère lu à tort. C'est une manière de résoudre un problème que pose l'écriture d'analyseurs lexicaux, ou la fin de certaines unités lexicales est indiquée par un caractère qui les suit sans en faire partie. Exemple : la lecture d'un nombre entier non négatif :

int lirentier(FILE *flot) { /* lecture d'un entier (simpliste) */
int c, x = 0;
c = getc(flot);
while ('0' <= c && c <= '9') {
x = 10 * x + c - '0';
c = getc(flot);
}
/* ici, c est le caractère suivant le nombre */
ungetc(c, flot);
return x;
}

⁵⁶Il s'agit d'entrées-sorties tamponnées, c'est-à-dire de simples transferts entre mémoires. S'il s'était agi d'opérations physiques, le gain de temps obtenu en utilisant getc à la place de fgetc aurait été négligeable devant le temps requis par l'entrée-sortie elle-même.

⁵⁷Ainsi, gets lit des caractères jusqu'à la rencontre de 'nn', sans se préoccuper de savoir si l'espace dans lequel ces caractères sont rangés est de taille suffisante pour les recevoir ; autrement dit, tout appel de gets peut entrainer un débordement de mémoire. C'est la raison pour laquelle on dit que tout programme comportant ne serait-ce qu'un appel de gets est bogué.

La fonction d'écriture sur l'unité de sortie standard (en principe l'écran du poste de travail) avec conversion et mise en forme des données est :

printf( format , expr1 , expr2 , ... exprn )

format est une chaine qui joue un rôle particulier. Elle est formée de caractères qui seront écrits normalement, mélangés à des indications sur les types des expressions expr1, expr2, ... exprn et sur l'aspect sous lequel il faut écrire les valeurs de ces expressions.

Cela fonctionne de la manière suivante : la fonction printf parcourt la chaine format et reconnait certains groupes de caractères comme étant des spécifications de format. C'est le caractère % qui déclenche cette reconnaissance. La fonction printf recopie sur le flot de sortie tout caractère qui ne fait pas partie d'une telle spécification. La ieme spécification détermine la manière dont la valeur de expri sera écrite. Les spécifications de format reconnues par la fonction printf sont expliquées dans la table 4 (page 91).

Notez que seuls les éléments 1 (le caractère %) et 6 (la lettre qui indique le type de la conversion) sont obligatoires dans une spécification de format.

Exemple 1. Supposons qu'on ait donné la déclaration-initialisation

float x = 123.456;

Voici une liste d'appels de printf, avec l'affichage produit par chacun :

Appel 					Affichage obtenu
printf(">%f<", x); 			>123.456001<
printf(">%12f<", x); 			> 123.456001<
printf(">%12.2f<", x); 			> 123.46<
printf(">%.2f<", x); 			>123.46<
printf(">%-12.2f<", x); 		>123.46 <
printf(">%+-12.2f<", x); 		>+123.46 <
printf(">% -12.2f<", x); 		> 123.46 <
printf(">%12.2f<", x); 			> 123.46<
printf(">%012.2f<", x); 		>000000123.46<
printf(">%.0f<", x); 			>123<
printf(">%#.0f<", x); 			>123.<

Exemple 2. La liste suivante illustre l'utilisation de la largeur et de la précision pour les chaines. Supposons avoir donné les déclarations :

char *s = "ABCDEFG";
int l = -10, n = 5;

Voici une liste d'appels de printf, avec l'affichage produit par chacun :

Appel 							Affichage obtenu
printf("printf(">%5s<", s); 				>ABCDEFG<
printf("printf(">%10s<", s); 				> ABCDEFG<
printf("printf(">%-10s<", s); 				>ABCDEFG <
printf("printf(">%10.5s<", s); 				> ABCDE<
printf("printf(">%-10.5s<", s); 			>ABCDE <
printf("printf(">%.5s<", s); 				>ABCDE<
printf("printf(">%*.*s<", l, n, s); 			>ABCDE <

La largeur du champ (cf. tableau 4, nº3) peut être indiquée par le caractère * à la place d'un nombre. Elle est alors définie par la valeur de l'argument dont c'est le tour, qui doit être de type entier. Il en est de même pour la spécification de la précision (cf. tableau 4, nº4). Par exemple, i et j étant des variables entières et x une variable flottante, l'expression

printf("%*.*f", i, j, x);

écrit la valeur de x sur un nombre de caractères égal à la valeur de i, avec un nombre de chiffres après la virgule égal à la valeur de j.

La fonction de lecture avec format à l'unité d'entrée standard (en principe le clavier du poste de travail) est

scanf( format , adresse1 , adresse2 , ... adressen )

L'argument format est une chaine qui indique la manière de convertir les caractères qui seront lus ; adresse1, adresse2, ... adressen indiquent les variables devant recevoir les données lues. Ce sont des « sorties » de la fonction scanf, par conséquent il est essentiel que ces arguments soient des adresses de variables à lire.

La fonction scanf constituant un vrai analyseur lexical, les données lues ont de nombreuses occasions d'être incorrectes et on peut s'attendre à ce que scanf soit d'un maniement difficile. L'expérience ne déçoit pas cette attente ! Voici un bon conseil : si un programme ne fonctionne pas comme il le devrait, commencez par vérifier les valeurs lues par la fonction scanf (par exemple avec des appels de printf suivant immédiatement les appels de scanf).

Les spécifications de format reconnues par la fonction scanf sont expliquées dans la table 5 (page 93). Fonctionnement : scanf parcourt le format. Elle rend la main lorsque la fin du format est atteinte ou sur une erreur. Jusque-là :

• Tout caractère ordinaire du format, c'est-à-dire qui n'est ni un caractère d'espacement (blanc, tabulation) ni un caractère faisant partie d'une spécification de format (commençant par %), doit s'identifier au caractère courant du flot d'entrée. Si cette identification a lieu, le caractère courant est lu, sans être rangé dans aucune variable, et le parcours du format se poursuit. Si l'identification n'a pas lieu, l'activation de scanf se termine.
• Les spécifications de format commencent par %. Elles indiquent la manière d'analyser les caractères lus sur le flot d'entrée et de ranger les valeurs ainsi obtenues. Voir le tableau 5.
• Dans le format, les caractères ordinaires et les spécifications peuvent être séparés entre eux par des caractères d'espacement. Le nombre de ces espacements est sans importance, mais leur présence indique que les données correspondantes peuvent être séparées dans le flot d'entrée par un nombre quelconque de caractères d'espacement ou de fin de ligne.
• S'il n'y a pas d'espacement, dans le format, entre les caractères ordinaires ou les spécifications, alors les données correspondantes dans le flot d'entrée doivent être adjacentes.
• Cependant, les espacements au début des nombres sont toujours sautés.

On peut mélanger des appels de scanf et d'autres fonctions de lecture. Chaque appel d'une telle fonction commence par lire le premier caractère que l'appel précédent n'a pas « consommé ».

Exemple 1. Lecture d'un entier :

scanf("%d", &x);

Exemple 2. Lecture de deux entiers séparés par une virgule et encadrés par une paire de parenthèses :

scanf("(%d,%d)", &x, &y);

Données correctes :

(22,33) ou ( 22, 33)

(des blancs, mais uniquement devant les nombres).

Données incorrectes :

( 22 , 33 )

(trop de blancs).

Exemple 3. Comme ci-dessus mais avec une syntaxe plus souple (les blancs sont tolérés partout) :

scanf(" (%d ,%d )", &x, &y);

Toutes les données de l'exemple précédent sont correctes. Exemple de donnée incorrecte :

( 22 ; 33 )

Exemple 4. Lecture d'un caractère 58 :

char calu;
...
scanf("%c", &calu);

Remarque. Nous avons indiqué par ailleurs qu'en C on range souvent les caractères dans des variables de type int afin de permettre la mémorisation d'une valeur « intruse », EOF. Cependant, notez bien qu'ici nous sommes obligés de déclarer la variable calu de type char ; le programme

int calu;
...
scanf("%c", &calu);

aurait été incorrect (bien qu'il puisse fonctionner correctement sur certains systèmes), car on y fournit à scanf l'adresse d'un entier (fait de plusieurs octets) pour y ranger un caractère, alors que scanf, d'après l'analyse du format, « croit » recevoir l'adresse d'un char (un octet). Or on ne doit pas faire d'hypothèse sur la manière dont sont organisés les octets qui composent un entier, le langage C ne précisant rien à ce sujet. Une autre solution correcte aurait été la suivante :

int calu;
char tmp;
...
scanf("%c", &tmp);
calu = tmp;

Exemple 5. Lecture d'un nombre entier et du caractère le suivant immédiatement, quel qu'il soit :

int nblu;
char calu;
...
scanf("%d%c", &nblu, &calu);

Exemple 6. Lecture d'un nombre entier et du premier caractère non blanc le suivant :

int nblu;
char calu;
...
scanf("%d %c", &nblu, &calu);

⁵⁸Rappelons que fgetc, getc et getchar font ce travail bien plus simplement.

A propos de « sauter les blancs ». Nous avons dit que les spécifications qui constituent le format peuvent être séparées entre elles par un ou plusieurs blancs, ce qui indique que les données à lire correspondantes peuvent alors être séparées par un nombre quelconque de blancs.

Pour la fonction scanf, les blancs dans le format se traduisent donc par l'ordre « à présent, sautez tous les caractères blancs qui se présentent ». Or la seule manière pour l'ordinateur de s'assurer qu'il a bien sauté tous les caractères blancs consiste à lire (sans le consommer) le premier caractère non blanc qui les suit. Si la lecture se fait dans un fichier, cela ne pose pas de problème, les caractères à lire existant tous dès le départ. Mais cela peut créer des situations confuses dans le cas d'une lecture interactive mettant en œuvre le clavier et un opérateur vivant. Exemple :

int x, y = 33;
...
printf("donne x : ");
scanf(" %d ", &x); 		/* aïe... */
printf("donne y : ");
scanf("%d", &y);
printf("x = %d, y = %d\n", x, y);

Parce qu'on a écrit, peut-être sans faire attention, des blancs après le format %d, le premier appel de scanf ci-dessus signifie « lisez un entier et tous les blancs qui le suivent ». L'opérateur constatera avec étonnement que pour que son premier nombre sont pris en compte il est obligé de composer le deuxième !

Exemple de dialogue (le signe ↵ représentant la frappe de la touche « Entrée ») :

donne x : 11↵
↵
↵ la machine ne réagit pas... ! ?
22↵
donne y : x = 11, y = 22

Notez que faire suivre le premier nombre d'un caractère non blanc conventionnel n'est pas une bonne solution car, ce caractère n'étant pas consommé, il fait échouer la lecture du second nombre :

donne x : 11↵
donne y : x = 11, y = 33

Leçon à retenir : dans le format de scanf, les blancs ne sont pas de la décoration, ils jouent un rôle bien précis.

A propos de la lecture d'un caractère. Une autre situation génératrice de confusion est celle ou des lectures de nombres sont suivies par des lectures de caractères ou de chaines. Par exemple, le programme naïf suivant lit des nombres les uns à la suite des autres et affiche le carré de chacun :

int x, c;
...
do {
	printf("donne un nombre : ");
	scanf("%d", &x); 	/* lecture d'un nombre */
	printf("%d ^ 2 = %d\n", x, x * x);
	printf("un autre calcul (O/N) ? ");
	c = getchar(); 		/* lecture d'un caractère */
}
while (c == 'O');
printf("au revoir...");\end{verbatim}

Voici un dialogue (la réplique de l'opérateur est soulignée, le signe ↵ représente la frappe de la touche « Entrée ») :

donne un nombre : 14↵
14 ^ 2 = 196
un autre calcul (O/N) ? au revoir...

La machine n'a pas attendu la réponse (O ou N) de l'opérateur... ! Que s'est-il passé ? L'opérateur a composé un nombre suivi immédiatement d'un caractère fin-de-ligne (traduction de la frappe de la touche « Entrée »).

Cette fin de ligne est inévitable mais n'a pas été consommée par scanf et est restée disponible pour des lectures ultérieures. L'appel de getchar (qui, dans l'esprit du programmeur, aurait dû provoquer une nouvelle lecture physique) trouve cette fin-de-ligne et l'affecte à c comme réponse, ce qui fait quitter la boucle. Ainsi, pour que ce programme se comporte comme son programmeur attend il faudrait qu'à la suite de l'invite « donne un nombre : », l'utilisateur saisisse un nombre immédiatement suivi d'un caractère O ou N qui est la réponse à une question qui ne lui a pas encore été posée !

Cela n'est pas raisonnable, bien sûr. La bonne manière de faire consiste à vider le tampon d'entrée avant de procéder à une lecture de caractère. Dans beaucoup d'environnements on peut faire cela avec la fonction

fflush :
int x, c;
char s[BUFSIZ];
...
do {
	printf("donne un nombre : ");
	scanf("%d", &x);
	printf("%d ^ 2 = %d\n", x, x * x);
	printf("un autre calcul (O/N) ? ");
	/* ici, le tampon de stdin contient (au moins) un 'nn' */
	fflush(stdin);
	/* maintenant le tampon est vide */
	c = getchar();
}
while (c == 'O');
printf("au revoir...");
...

Si la fonction fflush est inopérante sur le flot stdin (un tel comportement est permis par la norme du langage C) alors on peut résoudre le même problème en faisant des appels répétés de la fonction getchar, de manière à consommer tous les caractères restant dans le tampon jusqu'à la fin-de-ligne, ce caractère devant être consommé lui aussi. L'exemple ci-dessus devient

...
scanf("%d", &x);
printf("%d ^ 2 = %d\n", x, x * x);
printf("un autre calcul (O/N) ? ");
/* ici, le tampon de stdin contient (au moins) un 'nn' */
while (getchar() != '\n')
;
/* maintenant le tampon est vide */
c = getchar();
...

Voici la famille au complet, comme elle est déclarée (en syntaxe ANSI) dans le fichier <stdio.h> :

• printf

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

Nous avons décrit cette fonction. Ajoutons seulement qu'elle renvoie le nombre de caractères effectivement écrits (on utilise rarement cette information) ou un nombre négatif en cas d'erreur.

• fprintf

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

Comme printf mais sur le flot indiqué (à la place de stdout). Ainsi

printf( format , exp1 , ... , expk )

équivaut à

fprintf(stdout, format , exp1 , ... , expk )
int sprintf(char *destination, const char *format, ... )

Cette fonction effectue les mêmes mises en forme que ses deux sœurs, avec la différence que les caractères produits ne sont pas ajoutés à un flot, mais sont concaténés ensemble dans la chaine destination. Elle permet donc de dissocier les deux fonctionnalités de printf, transcodage et écriture des données, afin d'utiliser la première sans la deuxième.

• sscanf

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

Nous avons décrit cette fonction. Ajoutons qu'elle renvoie EOF si une fin de fichier ou une erreur a empêché toute lecture ; autrement elle rend le nombre de variables lues avec succès. Cette indication fournit une manière bien pratique pour détecter, dans les programmes simples, la fin d'une série de données. Exemple :

for(;;) {
	printf("donne un nombre : ");
	if (scanf("%d", &x) < 1)
		break;
	/* exploitation du nombre lu */
}
printf("au revoir...");

La boucle précédente sera arrêtée par n'importe quel caractère non blanc ne pouvant pas faire partie d'un nombre.

• fscanf

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

Comme scanf mais sur le flot indiqué (à la place de stdin). Ainsi

scanf( format , exp1 , ... , expk )

équivaut à

fscanf(stdin, format , exp1 , ... , expk )
int sscanf(const char *source, const char *format, ... )

Cette fonction effectue la même analyse lexicale que ses sœurs, avec la particularité que le texte analysé n'est pas pris dans un flot, mais dans la chaine source.

• fread

size t fread(void *destination, size t taille, size t nombre, FILE *flot)

Cette fonction essaye de lire sur le flot indiqué nombre objets, chacun ayant la taille indiquée, et les copie les uns à la suite des autres dans l'espace pointé par destination. Elle renvoie le nombre d'objets effectivement lus, qui peut être inférieur au nombre demandé, à cause de la rencontre de la fin du fichier 59, d'une erreur, etc.

• fwrite

size t fwrite(const void *source, size t taille, size t nombre, FILE *flot)

Cette fonction écrit les nombre objets, chacun ayant la taille indiquée, qui se trouvent les uns à la suite des autres à l'adresse indiquée par source. Elle renvoie le nombre d'objets écrits, qui peut être inférieur au nombre demandé (en cas d'erreur).

⁵⁹Lorsqu'un fichier est lu par des appels de la fonction fread, comparer avec zéro le nombre d'objets effectivement lus est la manière la plus pratique de détecter la fin du fichier.

• fseek

int fseek(FILE *flot, long deplacement, int origine)

Cette fonction positionne le pointeur du fichier associé au flot indiqué. La première lecture ou écriture ultérieure se fera à partir de la nouvelle position. Celle-ci est obtenue en ajoutant la valeur de déplacement à une valeur de base qui peut être la position courante, la fin ou le début du fichier. C'est l'argument origine qui indique de quelle base il s'agit ; la valeur de cet argument doit être une des constantes (définies dans <stdio.h>) :

• SEEK SET : base = le début du fichier
• SEEK CUR : base = la position courante
• SEEK END : base = la fin du fichier

La fonction renvoie zéro en cas de succès, une valeur non nulle en cas d'erreur. Sur un fichier de texte, il vaut mieux utiliser getpos et setpos.

Un appel de cette fonction sur un fichier en écriture produit la vidange du tampon (fseek implique fflush). Lire ci-après les explications sur l'accès relatif aux fichiers.

• frewind

void rewind(FILE *flot)

Positionnement au début du fichier du pointeur de fichier associé au flot indiqué. Un appel de cette fonction équivaut à fseek(flot, 0L, SEEK SET) suivi de la mise à zéro de tous les indicateurs d'erreur.

• fgetpos

void fgetpos(FILE *flot, fpos t *ptr)

Place dans ptr la position courante dans le flot indiqué en vue de son utilisation par setpos. Le type fpos t (défini dans <stdio.h>) a une taille suffisante pour contenir une telle information.

• fsetpos

void fsetpos(FILE *flot, const fpos t *ptr)

La valeur de ptr provenant d'un appel de getpos, cette fonction positionne le flot indiqué à l'emplacement correspondant.

L'accès relatif aux éléments des fichiers. La principale application des fonctions de positionnement est la réalisation de ce qu'on appelle l'accès relatif 60 ou parfois accès direct aux composantes d'un fichier : l'accès à une composante (on dit un enregistrement) que ce soit pour le lire ou pour l'écrire, à partir de la donnée de son rang dans le fichier sans être obligé d'accéder au préalable aux enregistrements qui le précèdent.

Pour donner une signification utilisable à la notion de « neme article », il faut que le fichier puisse être vu comme une suite d'articles de même taille (mais la bibliothèque C ignorera ce fait ; le fichier restera une suite d'octets). Cela s'obtient généralement en déclarant une structure qui représente un article, selon le modèle :

typedef struct {
...

champs dont se composent tous les articles

...
} ARTICLE;...

Un fichier destiné à être utilisé en accès relatif sera déclaré normalement, et ouvert de fa»con à autoriser les lectures et les écritures :

FILE *fichier;
...
fichier = fopen(nom , "rb+");

Si les articles sont numérotés à partir de zéro, l'opération « lecture de l'enregistrement de rang n » se programme alors selon le schéma suivant :

ARTICLE article;
...
fseek(fichier, n * sizeof(ARTICLE), SEEK_SET);
fread( & article, sizeof(ARTICLE), 1, fichier);
...
/* exploitation des valeurs des champs de article */
...

L'opération « écriture de la composante de rang n » obéit au schéma

ARTICLE article;
...
/* affectation des champs de article */
...
fseek(fichier, n * sizeof(ARTICLE), SEEK_SET);
fwrite( & article, sizeof(ARTICLE), 1, fichier);
...

Attention. La possibilité d'effectuer des lectures et des écritures sur le même fichier pose des problèmes dans la gestion des tampons associés au fichier que les fonctions de la bibliothèque standard ne résolvent pas. Ainsi chaque fois qu'une série de lectures sur un fichier va être suivie d'une série d'écritures sur le même fichier, ou réciproquement, il appartient au programmeur de prévoir l'écriture effective du tampon, soit par un appel explicite de la fonction fflush, soit par un appel d'une fonction de positionnement comme fseek. Notez que cette contrainte est satisfaite si on pratique des accès relatifs selon les schémas indiqués ci-dessus, puisqu'il y a toujours un appel de fseek entre deux accès au fichier, quel que soit leur mode.

⁶⁰L'accès relatif s'oppose à l'accès séquentiel, dans lequel une composante ne peut être lue ou écrite autrement qu'à la suite de la lecture ou de l'écriture de la composante qui la précède.

Le programme suivant fait une copie identique d'un fichier (ce programme n'est pas bien utile, généralement une fonction du système d'exploitation fait ce travail) :

#include <stdio.h>
#define PAS_D_ERREUR 		0 /* codes conventionnels */
#define ERREUR_OUVERTURE 	1 /* à l'usage du système */
#define ERREUR_CREATION 	2 /* d'exploitation */
FILE *srce, *dest;
 
main() {
	char tampon[512];
	int nombre;
 
	printf("source : ");
	gets(tampon);
	srce = fopen(tampon, "rb");
	if (srce == NULL)
		return ERREUR_OUVERTURE;
 
	printf("destination : ");
	gets(tampon);
	dest = fopen(tampon, "wb");
	if (dest == NULL)
	return ERREUR_CREATION;
 
	while ((nombre = fread(tampon, 1, 512, srce)) > 0)
		fwrite(tampon, 1, nombre, dest);
 
	fclose(dest);
	fclose(srce);
	return PAS_D_ERREUR;
}

L'essentiel de ce programme est sa boucle while. Elle se compose d'un appel de fread demandant la lecture de 512 octets, suivi d'un appel de fwrite pour écrire les nombre octets effectivement lus. Supposons que le fichier à copier comporte N octets ; ces deux opérations seront exécutées N 512 fois avec nombre égal à 512 puis

(sauf si N est multiple de 512) une dernière fois avec nombre égal au reste de la division de N par 512.

L'objet du programme suivant est la constitution d'un fichier d'articles à partir d'un fichier de texte qui se présente comme une répétition du groupe suivant :

• un nom et un prénom sur la même ligne ;
• une adresse sur la ligne suivante ;
• un entier seul sur une ligne, exprimant un certain « nombre de passages » (à un péage autoroutier).

Exemple

TOMBAL Pierre
Rue de la Gaiete de Vivre
	10
 
MENSOIF Gerard
Allee 'Les verts'
	20
		etc.

Le programme est indépendant de la nature du fichier de texte, qui peut être aussi bien le clavier d'un terminal qu'un fichier existant par ailleurs.

/* constitution d'un fichier d'articles */
/* à partir d'un fichier de texte */
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define PAS_D_ERREUR 		0
#define ERREUR_OUVERTURE 	1
#define ERREUR_CREATION 	2
#define ERREUR_ECRITURE 	3
#define ERREUR_FERMETURE 	4
 
struct 					/* un article du fichier */
	{
	char nom[32], prenom[32];
	char adresse[80];
	int nombre_de_passages;
	} art;
 
FILE *srce; 		/* fichier de texte */
FILE *dest; 		/* fichier binaire */
 
main() {
	char nom[256];
 
	printf("source : ");
	gets(nom);
	if ((srce = fopen(nom, "r")) == NULL)
		exit(ERREUR_OUVERTURE);
	printf("destination : ");
	gets(nom);
	if ((dest = fopen(nom, "wb")) == NULL)
		exit(ERREUR_CREATION);
 
for (;;) {
	if (fscanf(srce, " %s %s ", art.nom, art.prenom) != 2)
		break;
	fgets(art.adresse, 80, srce);
 
							/* enlevons le '\n' : */
	art.adresse[strlen(art.adresse) - 1] = '\0';
	fscanf(srce, " %d ", &art.nombre_de_passages);
	if (fwrite(&art, sizeof art, 1, dest) != 1)
		exit(ERREUR_ECRITURE);
}
if (fclose(dest) != 0)
	exit(ERREUR_ECRITURE);
exit(PAS_D_ERREUR);
}

Notez les diverses fonctions qui ont été utilisées pour lire du texte. Le nombre de passages est lu par scanf, car cette fonction est la seule qui convertit les nombres. Le nom et le prénom sont lus par scanf aussi, car cela nous arrange bien que les blancs soient pris pour des séparateurs et enlevés. Mais l'adresse est lue par gets, car elle peut contenir des blancs qui ne doivent pas être supprimés.

Dans le programme précédent nous avons vu un fichier binaire organisé en articles et traité séquentiellement (chaque article étant écrit à la suite du précédent). Voyons un exemple ou ce même fichier est traité en accès relatif.

Imaginons que le fichier créé à l'exemple précédent soit le fichier des abonnés à un certain péage, et que nous disposions par ailleurs d'un fichier binaire contenant les numéros des abonnés qui ont emprunté ce péage durant une période donnée. On nous demande d'écrire un programme pour incrémenter la valeur du champ nbr passages de chaque abonné concerné.

#include <stdio.h>
 
#define PAS_D_ERREUR 				0
#define ERREUR_OUVERTURE_ABONNES 	1
#define ERREUR_OUVERTURE_PASSAGES 	2
 
struct
	{
	char nom[32], prenom[32];
	char adresse[80];
	int nombre_de_passages;
	} art;
 
	FILE *passages, *abonnes;
 
	main() {
		char nom[256];
		long n;
 
		printf("fichier des passages : ");
		if ((passages = fopen(gets(nom), "rb")) == NULL)
			exit(ERREUR_OUVERTURE_PASSAGES);
		printf("fichier des abonnes : ");
		if ((abonnes = fopen(gets(nom), "rb+")) == NULL)
			exit(ERREUR_OUVERTURE_ABONNES);
 
		for (;;) {
			if (fread(&n, sizeof n, 1, passages) != 1)
				break;
			fseek(abonnes, n * sizeof art, SEEK_SET);
			fread(&art, sizeof art, 1, abonnes);
			art.nombre_de_passages++;
			fseek(abonnes, n * sizeof art, SEEK_SET);
			fwrite(&art, sizeof art, 1, abonnes);
			}
 
		fclose(abonnes);
		exit(PAS_D_ERREUR);
}