Le langage C - entrées/sorties

Les fonctions d'entrée-sortie sont déclarées dans le fichier stdio.h (en Anglais: Standard Input Output Functions), ne pas oublier de l'inclure (#include <stdio.h> en début de programme).

L'écriture vers la sortie standard (l'écran par défaut, voir Redirections, filtres et tubes) se fait avec la commande printf, la lecture avec la commande scanf. Dans les deux cas le 'f' signifie 'formatted', et indique qu'on peut contrôler différents aspects de l'affichage (nombre de chiffres après la virgule pour l'affichage d'une variable, ...).

Ecriture

La commande d'affichage

int printf (const char *texte [, variable [, variable [,...]]] ) ;

permet d'ecrire sur la sortie standard une chaîne de caractères, vers laquelle pointe l'argument texte, et éventuellement des variables dont on veut afficher la valeur. Ces variables sont passées en arguments à la fonction (paramètres optionnels), et doivent correspondre (dans l'ordre) à des codes de format dans la la chaîne de caractère texte. La valeur retournée (un entier) est le nombre de caractères écrits si il n'y a pas d'erreur, une valeur négative dans le cas contraire. Un exemple:

float x ;
int i ;
x = 15.3 ;
i = 5 ;
printf ("la variable x vaut %f\nla variable i vaut %d\n", x,i) ;

Le premier code de format, %f, et remplacé par la valeur de la première variable, x, et le deuxième code de format %d par la valeur de la variable i. Le caractère spécial \n correspond à un passage à la ligne. On obtient ainsi à l'écran:

la variable x vaut 15.3
la variable i vaut 5

D'une manière générale, lorsque dans la chaîne de caractère texte se trouve le caractère %, celà correspond à un format (dépendant des caractères qui suivent) dans lequel sera écrit la variable passée en argument (pour vraiment afficher un %, il faut en mettre deux à la suite: "%%"). Les arguments sont interprétés dans l'ordre. On peut également spécifier le nombre de caractères utilisés pour écrire une variable (nombre de chiffres significatifs, notation scientifique...) voir la partie sur les formats plus bas.

Lecture

int scanf (const char *format [, &variable [, &variable [,...]]] ) ;

permet de lire depuis l'entrée standard des données qui seront interprétées conformément au format indiqué dans la chaîne de caractère format, et seront stockées dans des variables dont on fournit l'adresse dans les arguments supplémentaires. Comme pour printf, les codes de format dans la chaîne format doivent être adaptés au type des variables lues. Les codes de format sont les mêmes que ceux pour printf. La valeur retournée est le nombre de données que la fonction a réussi à lire et interpréter conformément au format spécifié. Un exemple:

float x ;
int i ;
double dx ;
scanf ("%f", &x) ;   /*  lit un reel simple precision et le place dans x  */
scanf ("%d", &i) ;   /*  lit un entier et le place dans i  */
scanf ("%lf", &dx) ; /*  lit un reel double precision et le place dans dx  */

Formats

Pour afficher (avec printf) ou lire (avec scanf) une variable, il faut indiquer le format de ce qui doit être affiché/lu (ne serait-ce que parce qu'un type de variable (p. ex. un int) peut être affiché de manière différente (p. ex. en numération décimale ou binaire). Les formats on la structure générale suivante (pas d'espaces entre les paramètres, les paramètres optionnels sont entre crochets):

%[option][longueur][.precision][extra]aspect

Le seul paramètre obligatoire, l'aspect, est un caractère indiquant sous quelle forme on souhaite écrire/lire une donnée. Voici un tableau indiquant en première colonne les caractères courants pour l'aspect, leur effet en deuxième colonne et finalement le type de variable qui peut être écrite/lue sous cet aspect:

caractère aspect	interprétation	type de donnée associé
c	caractère	char
d ou i	entier représentation décimale	int
o	entier représentation octale	int
x ou X	entier représentation hexadécimale	int
e	réel sous la forme [-]d.dddd e [+/-]ddd	float ;
le	réel sous la forme [-]d.dddd e [+/-]ddd	double
f	réel sous la forme [-]dddd.dddd	float
lf	réel sous la forme [-]dddd.dddd	double
g	réel sous la forme la plus compacte (e ou f)	float
lg	réel sous la forme la plus compacte (le ou lf)	double
s	chaîne de caractères	char *

Note

Le l devant e, f ou g pour les double est facultatif en écriture (printf), mais obligatoire en lecture(scanf) sous peine de lecture fausse sans aucun message d'erreur!

Exemples de formats

On veut écrire une variable entière (a = 123456789) ou une variable réelle (b = 1.23456789) avec différents formats. Voici quelques possibilités: (printf("format", variable);) (Notez l'effet désastreux des erreurs de format...).

Format	Variable	Résultat
`%d`	`a (int)`	`123456789`
`%e`	`a (int)`	`3.211930e-273`
`%e`	`b (float)`	`1.234568e+00`
`%f`	`b (float)`	`1.234568`
`%7.3f`	`b (float)`	`1.235`
`%d`	`b (float)`	`1073741824`

$/!\$ Attention $/!\$

Appliquer un mauvais format lors d'un printf ou d'un scanf est une erreur commune. À moins d'avoir mis l'option -Wall lors de la compilation avec gcc, l'ordinateur ne vous préviendra pas, mais le résultat sera totalement imprévisible, comme vous pouvez le constater dans le tableau ci-dessus.

Exemples

Affichez, compilez et executez les programmes suivants :

prog1.c: afficher un message à l'écran (sortie standard).
prog12.c: Passage d'arguments par adresse : la fonction scanf.

Auteur(s) : Anciens, A. Daerr. Dernière modification : Wed Nov 22 01:08:56 2006. [valid. XHTML]