La console est un terme désignant souvent un terminal. Il s'agit en fait tout simplement de l'ensemble écran-clavier, qui réalise le "pont" entre la machine et l'utilisateur. Le clavier, interface d'entrée, permet à l'utilisateur de donner des ordres à la machine. L'écran, interface de sortie, permet à la machine de communiquer le résultat de son travail à l'utilisateur. Un programmeur, même débutant, se doit de maitriser les techniques d'interfacage console, même les plus rudimentaires.
Note : souvent les fonctions d'interface console nécessitent le fichier conio.h , il faudra donc l'inclure dans l'en-tête de vos fichiers.
En C, il existe plusieurs fonctions permettant de gerer le clavier. Souvent, il s'agit de la saisie de plusieurs caractères à la suite, avec la touche <entrée> à la fin. Il peut aussi s'agir d'un seul caractère. Le programme peut être bloquant (attendre la saisie) ou non (demander quelle est la saisie).
Saisie d'un seul caractère
Les fonctions suivantes n'attendent pas la touche <Entrée>. Elles servent à renvoyer UN SEUL caractère.
La fonction getch()
Cette fonction ne prend pas de paramètre, elle renvoie un entier 16 bits. On l'utilise de la manière suivante :
char c;c=getch();Ici, on a utilisé un caractère (char, 8 bits) pour la valeur de retour. Elle contient le code ASCII du caractère tapé. Celui-ci ne s'affiche pas à l'écran. Regardez un petit exemple (code source C ou fichier compilé EXE).
La fonction getche()
Cette fonction s'utilise de la même manière que la précédente, mais elle affiche à l'écran la touche tapée. Essayez !
La fonction kbhit()
Cette fonction teste si une touche est frappée. Elle n'attend pas une éventuelle frappe, et elle ne renvoie pas la valeur de la touche tapée. Elle renvoie 0 si aucune touche n'est tapée, une autre valeur non nulle sinon. Regardez un petit exemple (code source C ou fichier compilé EXE) sans vous occuper de la boucle.
Saisie d'une chaîne de caractères
Il existe plusieurs fonctions permettant de saisir une chaîne au clavier. Commençons par déclarer une chaîne, c'est à dire un tableau de caratères. Nous devons connaître à l'avance sa taille. Mettons que nous avons besoin de 15 lettres, nous allons alors déclarer un tableau de 16 caractères (et oui, la chaîne comporte toujours un caractère nul de fin ). La déclaration peut être comme suit :
char chaine[16];
Examinons maintenant les fonctions de saisie :
la fonction gets()
La fonction gets s'utilise comme suit :
gets(chaine);
On peut taper tous les caractères que l'on veut, gets rend la main lors de l'appui de la touche <Entrée>. Attention, gets présente un énorme défaut : ELLE NE VERIFIE PAS LE NOMBRE DE CARACTERES ENTRES ! On peut donc facilement planter la machine, il suffit de taper plus de caractères que prévu (dans notre cas, 17 suffisent !). Bien sûr, on peut se dire qu'en réservant 100 voire 500 caractères, on est tranquille ! Tout cela prend de la place en mémoire (bonjour les erreurs de débordement de pile !), et de toute façon, si l'utilisateur s'endort sur son clavier, il peut vite entrer plus de 1000 caractères (quand à une machine !!!!). Mauvaise solution, donc. Préférons donc programmer nous-mêmes une fonction new_gets plus sécurisée. Vous pouvez regarder ce code source (ou le fichier executable).
Saisie formatée (avec un format)
Pour sortir de la simple saisie (chaîne ou caractère), par exemple pour entrer un nombre réel, nous avons besoin de la "magique" fonction à tout faire du C, scanf.
La syntaxe particulière de scanf est :
scanf(<chaine de format>,<adresses>);
Ca à l'air compliqué comme ça, mais en fait... ça l'est.
Tout d'abord, il faut donner à scanf l'adresse de la variable à entrer. En C, on obtient l'adresse d'une variable (et non pas sa valeur) avec le préfixe &. Par exemple,
int i;
i=5;
scanf("%d",&i);
/* &i est l'adresse mémoire de i. ELLE NE VAUT PAS 5 */
Ensuite, il faut expliquer à scanf quel format on attend pour la variable. Son type bien sûr (entier, réel, chaîne...) mais aussi la façon dont elle s'écrit. Les châines de format, en C, commencent toutes par %. Les voici, avec un exemple :
Format Type et genre exemple %d entier décimal court, signé 1532, -35 %u entier décimal court, non signé 235, 32000 %ld entier décimal long, signé 563 524, -4 121 356 %lu entier décimal long, non signé 589 123 %c caractère 'q' %s chaîne de caractères "exemple n°3" %x entier hexadécimal court 0xA7F3 %lx entier hexadécimal long 0xF531AB03 %f réel simple précision 3.231536 %.2f réel simple précision avec 2 chiffres après la virgule 3.23 %0.2f réel simple précision avec 2 chiffres après la virgule et un chiffre min avant 0.23 %e réel simple précision en notation scientifique 2.3E-5 %g réel simple précision. Notation scientifique si besoin, sinon notation normale 1.2E15, 25.235 %p pointeur mémoire. La taille varie suivant les systèmes et les modèles mémoire A000:1200 %le réel double précision en notation scientifique %lf réel double précision en notation normale
Voici comment entrer au clavier un entier décimal signé :
int i;
scanf("%d",&i);
et pour entrer un nombre réel simple précision, en notation scientifique :
float x;
scanf("%e",&x);
On peut aussi demander deux nombres, séparés par des virgules :
int a,b;
scanf("%d,%d",&a,&b);
Et ici une chaine de caractères, puis un entier héxadécimal court :
int a;
char txt[64];
scanf("%s %x",&txt,&a);
Attention, scanf ne vérifie pas la taille des tableaux : si on entre plus de 64 caractères, la machine peut planter !
Note : scanf étant un peu lente et "lourde", elle n'est pas conseillée pour la saisie de caractères ou de chaînes simples.
On peut simuler l'appui au clavier d'une touche, par la fonction ungetch(char); Celle-ci envoie au "tampon" clavier une valeur qui sera retirée au prochain appel de getch() par exemple.
L'écran est le périphérique de sortie le plus utilisé : il est indispensable ! Donc, il est indispensable de savoir COMMENT le programmer.
Un écran peut être utilisé de deux manières : en mode texte (comme une console...ou un minitel) ou en mode graphique (ah, les jeux... ou les photos !). Bien sûr, la programmation graphique n'a aucun sens ici. D'abord, il n'y a pas de fonctions graphiques standard en C (il y a celles de Borland pour PC/DOS, pour PC/Win, pour LINUX, pour Mac, etc...). Ce chapitre se consacrera uniquement au mode texte et aux fonctions standard du C.
Affichage d'un caractère
Pour afficher un seul caractère, on a recours à la fonction putch. Elle s'utilise de manière très simple :
putch('a'); /* on affiche ici la lettre a à l'écran */
Les caractères spéciaux (le retour chariot par exemple) sont les suivants : (ils commencent tous par l'anti-slash \) :
\n : Combine un CR (carrier return) et un LF (line feed) : retour chariot et passage à la ligne.
\r : retour chariot
\l : passage à la ligne
\t : tabulation
\\ : anti-slash
Affichage d'une chaîne de caractères
Pour afficher toute une chaîne, on a le très pratique puts :
puts("Bonjour les copains !");
puts("\nPremière ligne\nDeux\tTrois\tQuatre\n");
Cette dernière instruction a priori étrange donne le résultat suivant :
Première ligne
Deux Trois Quatre
Bien sûr, le paramètre passé à puts peut être une variable.
Affichage formaté
Tout comme dans le chapitre précédent avec scanf, avec la fonction printf on va pouvoir afficher des sorties plus complexes. La syntaxe de printf est :
printf(<chaine avec formats>,<variables>);
Par exemple, les lignes suivantes :
float x=3.14;
int i=5;
printf("\nLa valeur de i est %d. Celle de x est %.4f",i,x);
afficheront à l'écran, après un saut à la ligne (\n):
la valeur de i est 5. Celle de x est 3.1400
On peut imaginer des sorties écran beaucoup plus compliquées.
Evidemment, il faut savoir effacer l'écran : cela se fait par la fonction clrscr();
Comme pour la plupart des fonctions d'entrée/sortie console, le fichier conio.h doit être inclus.
On peut avoir besoin également d'effacer la fin de la ligne, c'est à dire le texte se trouvant à la droite du curseur. Pour cela, on emploie la fonction clreol();
Déplacement du curseur texte à l'écran
Le curseur texte peut être déplacé n'importe où sur l'écran de la console. Il faut savoir comment cet écran est repéré. Les coordonnées correspondent à des caractères, et pas à des pixels comme en mode graphique. Le premier caractère en haut à gauche possède les coordonnées (1,1).
Les fonctions wherex() et wherey() permettent de savoir où se trouve le curseur.
La fonction gotoxy(int,int) permet de déplacer le curseur.
Par exemple, le programme ci-dessous montre les possibilités énoncées plus haut :
#include <conio.h>
#include <stdio.h>
void main(void)
{
int x,y;
puts("Essai 1"); /* on affiche pour le test */
x=wherex(); y=wherey(); /* on demande l'emplacement du curseur */
gotoxy(x+3,y-2); /* on le déplace de 3 caractères à droite et de 2 vers le haut */
puts("Essai 2"); /* deuxième affichage */
gotoxy(10,6); /* on va à la 10ième colonne, 6eme ligne */
puts("Essai 3"); /* et dernier affichage */
}
On pourra regretter que ne soient point abordées ici la gestion des couleurs du texte et du fond, ainsi que le graphisme. Ces points sont spécifiques à un système, voire à un compilateur ! Pour ceux qui sont interessés, je ferais peut-être ces chapitres pour les compilateurs Borland C (Turbo C) sous DOS et Windows (versions Turbo C++ de 1.0 à 3.1). Mais seulement s'il y a beaucoup de demandes !