Fonction de lecture getchar()
C'est une fonction sans paramètre qui « capte » la valeur du caractère lu à la position courante de l'entrée standard (le clavier) et le retourne. Quand un programme exécute cette fonction, le curseur dans la fenêtre d'exécution est « en attente », l'utilisateur doit alors taper au moins un caractère du clavier.
Ce caractère apparaît aussi à l'écran (en écho) puis il doit terminer sa saisie par la touche « return ».
#include <stdio.h>
int main()
{
char c;
c = getchar();
// le programme suspend son fonctionnement jusqu'a ce que l'utilisateur tape
// au moins un caractère puis la touche <return>
putchar(c);
}
L'utilisateur tape par exemple la touche <a> puis la touche <return>. Il a tapé deux caractères car le <return> est un caractère en fait c'est le caractère '\n' (NL).
On obtient à l'affichage :
a
a
Le premier 'a' affiché correspond à ce que tape l'utilisateur (c'est l'écho d'affichage), le second ‘a' correspond à l'affichage du caractère saisi réalisé avec "putchar".
Lorsque l'utilisateur tape quelque chose au clavier, les caractères tapés sont stockés dans une zone appelée zone tampon ou buffer. Le programme consomme les caractères de cette zone avec getchar().
L'appui sur la touche <return> provoque l'envoie du tampon vers le programme. Il ne vous a pas échappé que l'utilisateur a tapé 'a' puis 'return', le caractère qui correspond à la touche <return> est l'interligne, c'est-à-dire le caractère '\n', que nous noterons aussi <NL> dans le texte explicatif pour visualiser les effets de son affichage.
Il est toujours dans le tampon et peut être consommé.
#include <stdio.h>
int main()
{
char c;
c = getchar();
// le programme suspend son fonctionnement, il attend une donnée du clavier
// L'utilisateur tape le caractère 'a'
// puis <return>, le tampon contient deux caractères. Le programme reprend son
// Fonctionnement et ce premier getchar consomme le premier caractere 'a'.
// Dans la variable c il y a le caractere 'a'.
// Il reste toujours le caractere <return> dans le tampon.
c = getchar();
// Ce second getchar consomme le caractere <return>.
// Dans la variable c il y a le caractere <return>. Le tampon est vide.
putchar(c);
// On affiche donc un <return>, c-a-d '\n', c-a-d <NL>.
}
Pour les besoins de l'explication, nous écrirons explicitement <NL> quand le caractère est affiché.
A l'exécution si vous tapez le caractère 'a' suivit de <return>, vous aurez à l'écran :
a <NL>
<NL>
Le programme ne se bloque pas en attente d'un caractère de la part de l'utilisateur au deuxième "getchar()" car le tampon n'est pas vide.
On continue de consommer les caractères du tampon.
int main()
{
char c;
c = getchar();
// Le programme suspend son fonctionnement, il attend une donnée du clavier
// si vous tapez exactement : alpha<return>, vous consommez 'a'
putchar(c);
// vous affichez 'a'
c = getchar();
// Le tampon n'est pas vide, le programme ne bloque pas, vous consommez 'l'
putchar(c);
// vous affichez 'l' }
Le programme ci-dessus ne demande pas une nouvelle saisie au second getchar(). Il consomme les caractères disponibles dans le tampon. Et cela peut continuer tant que le tampon n'est pas vide.
Les deux fonctions "getchar" et "putchar" sont limitatives. On peut toujours convertir le caractère ou la suite de caractères en un type donné ou inversement (entier par exemple), mais pour faciliter l'échange, on utilise les entrées/sortie formatées suivantes qui ont été conçues pour cela.
