Professional Documents
Culture Documents
Cours 13T
Langage C et Gestion des Entres/Sorties
Rsum de Thorie
Version prliminaire
Deuxime Anne
Programme de Formation des Techniciens
Spcialiss en lectronique
DIRECTION DE LA RECHERCHE ET INGENIERIE DE LA FORMATION
Septembre 1996
Rsum de Thorie
RDACTION
Robert Pesant
DESSINS ET CONCEPTION GRAPHIQUE
Robert Pesant
RVISION TECHNIQUE
Robert Pesant
RVISION LINGUISTIQUE
Franois Gaudreau
COMMISSION DE VALIDATION
Formateurs de lOFPPT
Manipulation de donnes en C
Page ii
OFPPT/TECCART
Rsum de Thorie
Manipulation de donnes en C
Page iii
OFPPT/TECCART
Manipulation de donnes en C
Constantes
Types de constantes
Le Tableau 3 -1 prsente les trois types de constantes du langage C: les constantes entires,
relles et caractres.
T AB L E AU 3-1: L E S
Type
Entire, entire longue
Relle
Description
Dcimale
Octale
Hexadcimale
Dcimale
Imprimable
Caractre
Non-imprimable
Chane
C O N S TAN T E S
Exemples
68, -31, 2345, 2345L
015, 0, 077, 077L
0x15, 0xFFFF, 0x9A2BL
0.12e2, 1.2e3, 12e-6, -3.1
a, (, 8, G
\0, \\, \xFD, \137
1. \a: sonnerie
2. \b: espacement arrire
3. \f: saut de page
4. \n: interligne
5. \r: retour de chariot
6. \t: tabulation horizontale
7. \v: tabulation verticale
8. \\: oblique inverse
9. \: guillemets
10. \:apostrophe
11. \0: nul
12. \ccc: caractre de valeur octale cc (\000 \377)
13. \xcc: caractre de valeur hexadcimale cc (\x00 \xFF)
Une \n chane!
Pour les constantes entires, nous utiliserons seulement les constantes dcimales et
hexadcimales, car l'usage du systme octal n'est pas assez rpandu. Les constantes entires
hexadcimales doivent dbuter par 0x ou 0X, et non par $ comme en assembleur: 0xFF. Une
constante entire est limite deux octets alors qu'une constante entire longue a une longueur
de quatre octets. Un L est ajout la valeur numrique de la constante entire longue: 128
occupe 2 octets; 128L occupe 4 octets. Le systme binaire n'est pas utilis en C.
Pour les constantes relles, la notation dcimale (ex.: 112.34) et la notation scientifique (ex.:
1.1234e2) sont reconnues par le C. Dans le cas des constantes relles dcimales qui n'ont pas de
partie fractionnaire, on ajoute .0 pour que le compilateur ne les traitent pas comme des constantes
entires: 105.0, 34.0.
Il y a trois types de constantes caractres: les caractres imprimables, les caractres nonimprimables et les chanes de caractres. Une constante caractre est entoure d'apostrophes: 'A',
'\n'. Le caractre '\' prcde un caractre non-imprimable. Une constante chane de caractres est
entoure de guillemets anglais: "Comment a va?".
/* Programme:
* =========
*
* Auteur:
* Date:
* Rvision:
* Version:
*
* Volume:
* Fichier:
*
* Description:
*
*/
CONST.C
=======
Robert Pesant
08/10/1992
08/10/1992
V1.0
COURS_13T
\CHAP.003\CONST.C
Affichage des diffrents types de constantes
l'aide de la fonction printf()
#include <stdio.h>
#include <conio.h>
void main(void)
{
/* Efface l'cran */
clrscr();
printf("Affichage de constantes entires en dcimal et en hexadcimal.\n\n");
printf("La premire constante entire est: %d.\n", 356);
printf("Les deuxime et troisime constantes entires sont: %d et %d.\n", 12, -45);
printf("Les deuxime et troisime constantes entires sont: %x et %x.\n", 12, -45);
printf("Les deuxime et troisime constantes entires sont: %X et %X.\n", 12, -45);
printf("\n\nAffichage de constantes relles.\n\n");
printf("La premire constante relle est: %f.\n", 567.37);
printf("La deuxime constante relle est: %e.\n", 3454.72);
printf("\n\nAffichage de constantes caractre.\n\n");
printf("La premire constante caractre est: %c.\n", 'a');
printf("La premire chane de caractres est: %s.\n", "All!, comment a va?");
printf("\n\nUne touche pour quitter...");
F I G U R E 3-1: E X C U T I ON
DE
CO NS T.E X E
Prcisons, avant d'aller plus loin, que le code de format d'impression est un outil qui nous permet
d'interprter et de visualiser de diffrentes faons une constante (et ventuellement la valeur d'une
variable). Cest une sorte de lunette dapproche avec diffrents filtres. Les instructions
printf("Les deuxime et troisime constantes entires sont: %x et %x.\n", 12, -45);
printf("Les deuxime et troisime constantes entires sont: %X et %X.\n", 12, -45);
affichent respectivement les constantes 12 et -45 en hexadcimal minuscule (%x) et hexadcimal
majuscule (%X).
Modifiez le programme CONST.C en ajoutant la ligne suivante:
printf("Ces trois constantes entires sont quivalentes: %d, %X, %c.\n", 75, 75, 75);
Vous devriez voir apparatre dans l'ordre 75, 4B et K, car 75 ou son quivalent hexadcimal 4B
est le code ASCII de la lettre K! En conclusion, printf() offre la possibilit d'examiner une valeur
numrique de plusieurs faons, selon le code de format utilis.
Variables
Qu'est-ce qu'une variable?
Une variable est un emplacement mmoire qui sert stocker une valeur et qui se verra
attribuer un nom, appel identificateur. Il existe en C des variables de grandeur et de
reprsentation diffrentes, dfinies par les types de donnes.
Classification des types de donnes
Le Tableau 3 -2 prsente tous les types de donnes qui nous permettront de dfinir les variables.
Les deux grandes catgories sont les types simples et les types drivs.
Les variables de type driv sont les tableaux, les structures, les unions et les pointeurs. L'tude
de ces types de variables complexes est reporte plus tard.
Les variables de type simple se subdivisent en variables entires et relles. Les variables simples
entires peuvent tre de type caractre ou de type entier. Les mots-cls char et int seront utiliss
pour les distinguer. Une variable de type char occupe un octet (byte) en mmoire et sa valeur est
signe par dfaut. Une variable de type int occupe deux octets (word) en mmoire et sa valeur
est galement signe par dfaut. Les mots-cls signed, unsigned, short et long sont appels des
modificateurs et sont utiliss pour changer la grandeur par dfaut d'une variable en mmoire. Le
Tableau 3 -2 prcise le nombre de cases mmoires occupes par chaque type de variable sur un
compatible IBM. Ce nombre peut changer sur d'autres systmes d'exploitation.
Ne vous en faites pas si cette liste semble impressionnante. Dans la quasi totalit des applications,
nous nous limiterons aux types de donnes suivants.
1.
char, unsigned char: Codes ASCII et registres de 8 bits des cartes d'acquisition de
_____________donnes, des ports parallle et srie.
2.
int, unsigned int:
Compteurs, variables entires.
3.
double:
Traitement de donnes, calculs.
Pour obtenir plus de prcision dans les calculs, seul le type de donne double sera utilis; le type
de donne float sera systmatiquement vit.
T AB L E AU 3-2: L E S
Type simple
Entire
Relle
Variable et Variable
modifie
char
signed char
unsigned char
int
short int
long int
signed int
unsigned int
signed short int
unsigned short int
signed long int
unsigned long int
float
double
long double
Type driv
Tableau
Structure
Union
Pointeur
Variable
*
*
*
(adresse)
VAR I AB L E S
Octets
Bits
1
1
1
2
2
4
2
2
2
2
4
4
4
8
10
8
8
8
16
16
32
16
16
16
16
32
32
32
64
80
-128 +127
-128 +127
0 255
-32768 +32767
-32768 +32767
-2147483648 +2147483647
-32768 +32767
0 65535
-32768 +32767
0 65535
-2147483648 +2147483647
0 4294967295
3.4e-38 3.4e+38
1.7e-308 1.7e+308
3.4e-4932 3.4e+4932
Variable modifie
ne sapplique pas
ne sapplique pas
ne sapplique pas
ne sapplique pas
Octets
*
*
*
2
Bits
*
*
*
16
Dans le rpertoire CHAP.003 sur la disquette COURS_13T, vous trouverez le fichier source
DATASIZE.C. Ce programme nous a permis de vrifier la grandeur mmoire des types de
donnes en C sur un compatible IBM. Chargez-le, compilez-le et excutez-le. Observez les
rsultats et analysez la technique utilise. Loprateur sizeof sera prsent plus loin, dans un
tableau sur les oprateurs.
Identificateur d'une variable
Pour choisir l'identificateur d'une variable (son nom), vous pouvez utiliser:
4.
les lettres minuscules de a z , sans accents, ni cdille, ni trma;
5.
les lettres majuscules de A Z ;
6.
le caractre de soulignement _ ;
7.
les chiffres de 0 9 , sauf comme premier caractre.
Toutefois, cause du style que nous avons adopt, vous ne devez pas faire usage des majuscules
dans les identificateurs de variables.
Les identificateurs dj rservs dans les fichiers d'en-tte de Borland C++ commencent par le
caractre de soulignement _ . Pour viter un conflit possible entre ces identificateurs et les
vtres, il est dconseill de dbuter un identificateur avec un _ . C'est encore une question de
style.
Un compilateur respectant le Standard ANSI reconnat les 31 premiers caractres d'un
identificateur. Borland C++ en reconnat jusqu' 32. La plupart des programmeurs en C
prfrent utiliser des identificateurs significatifs pour limiter le nombre de commentaires: il est
souhaitable d'utiliser temperature_celsius et pression, par exemple, plutt que var1 et var2.
L'aide de Borland C++ sur printf() rvlera tous les raffinements du format d'impression. En
guise d'introduction, le Tableau 3 -3 prsente quelques exemples simples.
T AB L E AU 3- 3: Q U E L Q U E S
Valeur
659
Format
%d
659
%5d
-659
%5d
659
%+5d
659
%-5d
659
%06d
2.348
%f
2.348
%.1f
2.3
2.348
%5.2f
2.35
-----
E X E M P L E S D E F O R M AT D ' I M P R E S S I O N
Affichage
659
Remarque
Aucun champ spcifi.
659
-----659
----+659
----659
----000659
-----2.348000
FORMAT.C
========
Robert Pesant
11/10/1992
11/10/1992
V1.0
COURS_13T
\CHAP.003\FORMAT.C
Test des formats d'impression de la fonction printf()
pour l'affichage de variables.
Note: Des crochets encadrent les formats d'impression
pour dlimiter les champs d'impression des variables.
#include <stdio.h>
#include <conio.h>
void main(void)
{
char c = 'A';
int i = 654;
double x = 172.5678;
clrscr();
printf("La
printf("La
printf("La
printf("La
variable
variable
variable
variable
caractre
entire
relle
relle
'c'=
'i'=
'x'=
'x'=
<%d>
<%d>
<%f>
<%e>
F I G U R E 3-2: E X C U T I ON
DE
F O R MAT.E X E
F I G U R E 3-3: R E P R S E N TATI O N
D ' U N E VAR I AB L E E N M M O I R E
Le programme qui suit, ADR&DATA.C, utilise nouveau printf() pour afficher les adresses et
les valeurs de variables de types diffrents. Le format d'impression %p sert afficher l'adresse en
hexadcimal. Observez les adresses des variables et vrifiez le nombre d'octets mmoire occups
par chacune d'entre elles en vous rfrant au Tableau 3 -2.
/* Programme:
* =========
*
* Auteur:
* Date:
* Rvision:
* Version:
*
* Volume:
* Fichier:
*
* Description:
*
*/
ADR&DATA.C
==========
Robert Pesant
12/07/1993
12/07/1993
V1.0
COURS_13T
\CHAP.003\ADR&DATA.C
Ce programme imprime les adresses et les valeurs
de variables de diffrents types.
#include <stdio.h>
#include <conio.h>
void main(void)
{
char
var_char
char
var_char1
int
var_int
int
var_int1
float
var_float
double var_double
char
var_char2
char
var_char3
int
var_int2
clrscr();
=
=
=
=
=
=
=
=
=
'A';
'B';
359;
644;
359.0;
359.0;
'C';
'D';
888;
/*
/*
/*
/*
/*
/*
/*
/*
/*
char:
1 byte,
8 bits */
char:
1 byte,
8 bits */
short int, int: 2 bytes, 16 bits */
short int, int: 2 bytes, 16 bits */
float:
4 bytes, 32 bits */
double:
8 bytes, 64 bits */
char:
1 byte,
8 bits */
char:
1 byte,
8 bits */
short int, int: 2 bytes, 16 bits */
printf("
printf("
Adresse
-------
printf("var_char ...:
printf("var_char1 ..:
printf("var_int ....:
printf("var_int1 ...:
printf("var_float ..:
printf("var_double .:
printf("var_char2 ..:
printf("var_char3 ..:
printf("var_int2 ...:
$%p
$%p
$%p
$%p
$%p
$%p
$%p
$%p
$%p
Valeur\n");
------\n\n");
%c\n",
%c\n",
%d\n",
%d\n",
%.1f\n",
%.1f\n",
%c\n",
%c\n",
%d\n",
&var_char,
&var_char1,
&var_int,
&var_int1,
&var_float,
&var_double,
&var_char2,
&var_char3,
&var_int2,
var_char
var_char1
var_int
var_int1
var_float
var_double
var_char2
var_char3
var_int2
);
);
);
);
);
);
);
);
);
printf("\n\nFin du programme\n\n\n");
F I G U R E 3- 4: E X C U T I O N
DE
ADR&DATA. E X E
Oprateurs
Classification et description
Un oprateur est un symbole qui reprsente une opration effectuer sur un ou plusieurs
oprandes. Le Tableau 3 -4 prsente la liste de tous les oprateurs disponibles en C. L'usage des
plus exotiques sera expliqu en dtail quand nous en aurons besoin.
Niveau de priorit des oprateurs
Le niveau de priorit des oprateurs dtermine dans quel ordre ceux-ci seront appliqus lors de
l'valuation d'une expression: les oprateurs de niveau plus lev seront toujours valus en
premier.
Lorsque plusieurs oprateurs de mme niveau de priorit se trouvent dans une mme expression,
il faut tenir compte de l'associativit: l'valuation des oprateurs s'effectue de gauche droite de
l'expression, sauf pour les oprateurs d'affectation (niveau 2) et les oprateurs unaires (niveau
14).
Pour viter toute confusion, n'hsitez pas faire usage de parenthses: leur niveau de priorit est
en effet le plus lev de tous; vous n'aurez donc pas vous souvenir de toutes les rgles
prsentes au Tableau 3 -5.
T AB L E AU 3- 4: L E S
Oprateurs arithmtiques
Fonction
Symbole
Addition
+
Soustraction
Multiplication
*
Division
/
Modulo
%
O P R ATE U R S
Remarques
Note: Ces oprateurs ne modifient pas la valeur de la variable, sauf si le rsultat de l'opration affecte celle-ci:
a>>2 ne change pas la valeur de a, a = a>>2 change la valeur de a.
Oprateurs logiques
Fonction
Symbole Remarques
ET
&&
((a>2) && (a<10)) --> VRAI si a = 6, FAUX si a = 16
OU
||
((a<2) || (a>10)) --> FAUX si a = 6, VRAI si a = 16
Ngation
!
!((a<2) || (a>10)) --> VRAI si a = 6, FAUX si a = 16
Note: Ces oprateurs servent tester l'tat logique d'une expression: VRAI ou FAUX, OUI ou NON, 0 ou
1.Une valeur numrique peut galement tre teste: VRAI si diffrente de 0, FAUX si gale 0.
Oprateurs de relation
Fonction
Symbole Remarques
Plus grand que
>
Plus petit que
<
Plus grand ou gal
>=
Plus petit ou gal
<=
Identique
==
Attention! Trop souvent confondu avec l'oprateur d'affectation =
Diffrent de
!=
Note: Ces oprateurs servent comparer des expressions. Le rsultat des oprations est VRAI ou FAUX.
Oprateurs daffectation
Fonction
Symbole Remarques
Affectation simple
=
Ajoute et affecte
+=
a += b; quivaut a = a + b;
Soustrait et affecte
-=
a -= b; quivaut a = a - b;
Multiplie et affecte
*=
a *= b; quivaut a = a * b;
Divise et affecte
/=
a /= b; quivaut a = a / b;
Modulo et affecte
%=
a %= b; quivaut a = a % b;
OU (bit) et affecte
|=
a |= b; quivaut a = a | b;
OU exc (bit) et aff
^=
a ^= b; quivaut a = a ^ b;
ET (bit) et affecte
&=
a &= b; quivaut a = a & b;
Dcale droite et affecte
>>=
a >>= b; quivaut a = a >> b;
Dcale gauche et affecte
<<=
a <<= b; quivaut a = a << b;
Note: Ces oprateurs modifient la valeur des variables.
b = 3, a = 94;
Oprateur conditionnel
Fonction
Symbole Remarques
valuation conditionnelle
?:
min = (a<b)?a:b; --> si (a<b) est VRAI, min = a;, sinon min = b;
Note: L'utilisation de cet oprateur fait partie des thmes traits au chapitre 4.
Oprateurs
Fonction
Incrmentation
Symbole
++
Oprateurs primaires
Fonction
Parenthse
Expression dindice
Slecteur de membre
Slecteur de membre
Symbole
()
[]
->
.
Remarques
c = a + (b++); --> b = b + 1 aprs excution de l'instruction
c = a + (++b); --> b = b + 1 avant excution de l'instruction
-Dcrmentattion
c = a + (b--); --> b = b - 1 aprs excution de l'instruction
c = a + (--b); --> b = b - 1 avant excution de l'instruction
(nomType) char a; int b; b = (int)a; --> une copie de la valeur de a est transforme
Conversion explicite
en int avant d'tre dpose dans b
Adressage indirect
*
*ptr = a; --> copie la valeur de a l'adresse pointe par ptr
Adresse de
&
&a est l'adresse de a
value grandeur mmoire
sizeof
sizeof(expr),
sizeof(nomType)
Plus unaire
+
force l'valuation d'une expression avant une autre cause de son niveau
de priorit
Moins unaire
-a est le complment 2 de a
Note: Un oprateur unaire est un oprateur qui ncessite 1 seul oprande: ++ dans (a++).
Un oprateur binaire est un oprateur qui ncessite 2 oprandes: + dans (a + b).
Remarques
char tableau[8];
tableau[3] = a + tableau[5];
slection par pointeur: ptrstruct->mois = 12;
slection par la structure: date.mois = 12;
T AB L E AU 3-5: P R I O R I T
Niveau de
priorit
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
Type doprateur
Primaire
Unaire
Arithmtique
Arithmtique
De manipulation de bits
De relation
De relation
De manipulation de bits
De manipulation de bits
De manipulation de bits
Logique
Logique
Conditionnel
D'affectation
D'valuation squentielle
D E S O P R ATE U R S
Oprateurs
() []
++ -*
+ >> <<
> <
== !=
&
^
|
&&
||
?:
= +=
,
.
->
(nomType) *
/
%
Associativit
& sizeof
>= <=
-= *= /= %=
|=
^= &= >>=<<=
--->
<----->
--->
--->
--->
--->
--->
--->
--->
--->
--->
--->
<----->
NOMTYPE.C
=========
Robert Pesant
28/09/1992
12/10/1992
V1.1
COURS_13T
\CHAP.003\NOMTYPE.C
Test de prcision sur les rsultats
d'oprations arithmtiques sur des entiers
#include <stdio.h>
#include <conio.h>
void main(void)
{
int a, b, c;
double moyenne1, moyenne2, moyenne3;
clrscr();
a = 3; b
moyenne1
moyenne2
moyenne3
=
=
=
=
4; c = 6;
(a+b+c)/3;
(a+b+c)/3.0;
((double)a+b+c)/3;
printf("a = %d
b
printf("\nLa moyenne
printf("\nLa moyenne
printf("\nLa moyenne
= %d
c = %d\n", a, b, c);
de ces 3 nombres, selon la mthode 1, est: %6.2f", moyenne1);
de ces 3 nombres, selon la mthode 2, est: %6.2f", moyenne2);
de ces 3 nombres, selon la mthode 3, est: %6.2f\n\n", moyenne3);
F I G U R E 3- 5: E X C U T I O N
DE
NO M T Y P E . E X E
TSTPUTCH.C
==========
Robert Pesant
03/02/1993
03/02/1993
V1.0
COURS_13T
\CHAP.003\TSTPUTCH.C
Essai de la fonction putch().
#include <stdio.h>
#include <conio.h>
void main(void)
{
int c = 'A';
clrscr();
printf("Essai de la fonction putch().\n\n");
putch(c); putch('l'); putch('l'); putch('o'); putch('\n');
putch('t'); putch('o'); putch('i'); putch('!'); putch('\n'); putch('\r');
putch('!'); putch('!'); putch('!');
printf("\n\nAttention!\a\n");
printf("putch() interprte \'\\n\' comme un changement de ligne seulement.\n");
printf("putch() doit utiliser un \'\\r\' pour effectuer un retour de chariot.\n");
F I G U R E 3-6: E X C U T I ON
DE
TSTPUTCH.EXE
Fonction puts()
La fonction puts() sert afficher une chane de caractres. Cette chane peut tre forme de
caractres imprimables et/ou non-imprimables. Cependant, elle ne peut pas contenir des codes de
format d'impression comme printf(). De plus, puts() insre automatiquement un "\n" la fin de
la chane. On peut toutefois ajouter un "\n" la chane si on veut que puts() excute un deuxime
changement de ligne avec retour de chariot.
/* Programme:
* =========
*
* Auteur:
* Date:
* Rvision:
* Version:
*
* Volume:
* Fichier:
*
* Description:
*/
TESTPUTS.C
==========
Robert Pesant
21/02/1993
21/02/1993
V1.0
COURS_13T
\CHAP.003\TESTPUTS.C
Essai de la fonction puts().
#include <stdio.h>
#include <conio.h>
void main(void)
{
clrscr();
puts("Essai de la fonction puts().\n");
puts("Allo toi!");
puts("Comment a va?");
puts("\nAttention!\a");
puts("puts() ajoute automatiquement un \'\\n\' la fin de la chane de caractres!\n");
}
F I G U R E 3- 7: E X C U T I O N
DE
TESTPUTS.EXE
TSTGETCH.C
==========
Robert Pesant
18/02/1990
09/04/1995
V2.1
COURS_13T
\CHAP.003\TSTGETCH.C
Essai de la fonction getch().
#include <stdio.h>
#include <conio.h>
void main(void)
{
int c = 0;
clrscr();
printf("Appuyez sur une touche. Faites <Esc> pour quitter.\n\n");
while(c != 27)
{
c = getch();
putch(c); putch('\n'); putch('\r');
}
printf("\nFin!\a");
La Figure 3 -8 montre un exemple typique de sortie l'cran que peut produire l'excution du
programme.
F I G U R E 3- 8: E X C U T I O N
DE
TSTGETCH.EXE
Fonction getche()
Le programme de test TSGETCHE.C donne la mme sortie l'cran que TSTGETCH.C. Vous
remarquerez toutefois que la ligne putch(c); a t limine parce que la fonction getche(), qui
attend une touche comme getch(), effectue en plus un cho l'cran.
/* Programme:
* =========
*
* Auteur:
* Date:
* Rvision:
* Version:
*
* Volume:
* Fichier:
*
* Description:
*/
TSGETCHE.C
==========
Robert Pesant
18/02/1990
09/04/1995
V2.1
COURS_13T
\CHAP.003\TSGETCHE.C
Essai de la fonction getche().
#include <stdio.h>
#include <conio.h>
void main(void)
{
int c = 0;
clrscr();
printf("Appuyez sur une touche. Faites <Esc> pour quitter.\n\n");
while(c != 27)
{
c = getche();
putch('\n'); putch('\r');
}
printf("\nFin!\a");
Fonction kbhit()
Contrairement getch() et getche(), kbhit() n'attend pas que l'usager appuie sur une touche
lorsqu'elle est appele. Son rle est de vrifier la prsence d'une touche dans le tampon du clavier,
sans vider ce dernier. Cette fonction est trs utile lorsque les instructions d'une boucle doivent
tre constamment excutes jusqu' l'intervention de l'usager.
La valeur numrique, retourne par kbhit() ainsi que l'tat logique correspondant, sont prsents
au Tableau 3 -6, en fonction de l'tat du tampon du clavier.
T AB L E AU 3- 6: F ON C T I O N N E M E N T
Tampon du clavier
Vide
Non vide
D E K B H I T ()
tat logique
0, FAUX
1, VRAI
Comme on le verra au prochain chapitre, une boucle while a besoin d'une condition VRAI pour
poursuivre son excution. Or, dans le programme qui suit, cette boucle doit tre excute tant
que le tampon est vide. D'aprs le Tableau 3 -6, il faut donc inverser l'tat logique correspondant
la valeur numrique retourne par kbhit() avec l'oprateur de ngation !, de l l'expression !
kbhit().
La ligne getch(); est utilise pour vider le tampon du clavier (sans fournir un cho l'cran) car
kbhit() est incapable de le faire.
Trois nouvelles fonctions sont introduites dans TSTKBHIT.C: sleep() qui produit un dlai
calcul en secondes, gotoxy() qui positionne le curseur entre les coordonnes limites de l'cran
(1,1) (80,25) et strlen() qui mesure la longueur d'une chane de caractres. Vous constaterez
que l'instruction gotoxy((41 - strlen("CHRONOMETRE")/2),1); permet de centrer la chane
de caractres CHRONOMETRE.
/* Programme:
* =========
*
* Auteur:
* Date:
* Rvision:
* Version:
*
* Volume:
* Fichier:
*
* Description:
*/
#include
#include
#include
#include
TSTKBHIT.C
==========
Robert Pesant
18/02/1990
04/08/1991
V1.1
COURS_13T
\CHAP.003\TSTKBHIT.C
Essai de la fonction kbhit().
<stdio.h>
<conio.h>
<string.h>
<dos.h>
void main(void)
{
int i = 0;
clrscr();
gotoxy((41 - strlen("CHRONOMETRE")/2),1);
printf("CHRONOMETRE");
gotoxy((41 - strlen("***********")/2),2);
printf("***********");
while(!kbhit())
{
gotoxy((41 - strlen("
secondes")/2),4);
printf("%3d secondes", i++);
sleep(1);
}
getch();
gotoxy((41 - strlen("Fin!")/2),6);
printf("Fin!\a");
Lors de l'essai du programme, une touche a t enfonce 6 secondes aprs le dbut de l'excution
(c.f. Figure 3 -9).
F I G U R E 3- 9: E X C U T I O N
DE
T S T K B HI T.E X E
Fonction scanf()
Pour entrer au clavier des nombres de plusieurs chiffres, Borland C++ met notre disposition la
fonction scanf(). Cette fonction utilise les mmes paramtres formats que printf().
Son utilisation n'est toutefois pas vidente: ce que l'on tape doit tre conforme au format auquel
s'attend scanf(). Pour viter les problmes, on se limitera aux cas prsents au Tableau 3 -7.
T AB L E AU 3-7: U S AG E
Type de la valeur numrique
entre au clavier
entier dcimal
entier hexadcimal
rel dcimal
L I M I T D E S C AN F ()
int a;
unsigned int b;
double c;
scanf(%d, &a);
scanf(%x, &b);
scanf(%lf, &c);
Prcisons que le code de conversion "f" s'applique aux donnes de type float et double dans le
cas de la fonction printf(). Par contre, pour la fonction scanf(), une distinction s'impose: "f" ne
s'applique qu'aux donnes de type float; pour les donnes de type double, il faut utiliser le code
de conversion "lf" qui signifie long float.
Attention! Si scanf() rencontre un caractre inattendu, elle cesse l'acquisition de la valeur sans
vider compltement le tampon du clavier: si on tape l'entier 34z5, 34 sera la valeur accepte et z5
restera dans le tampon; si on tape l'entier z45, la valeur de la variable ne sera mme pas change
car scanf() ne peut rien extraire du tampon du clavier. De plus, scanf() sera totalement
impuissante lorsqu'elle tentera de relire le clavier, car elle sera toujours aux prises avec un
caractre impossible interprter. Pour rgler ce problme, il faut utiliser l'nonc fflush(stdin);
pour nettoyer le tampon du clavier aprs chaque appel de scanf().
Le programme TSTSCANF.C illustre l'utilisation de la fonction scanf(). Faites l'essai du
programme avec des valeurs permises et interdites.
/* Programme:
* =========
*
* Auteur:
* Date:
* Rvision:
* Version:
*
* Volume:
* Fichier:
*
* Description:
*
*
*
*
*/
TSTSCANF.C
==========
Robert Pesant
28/09/1992
12/10/1992
V2.0
COURS_13T
\CHAP.003\TSTSCANF.C
Utilisation de la fonction scanf() pour entrer des
valeurs au clavier et de fflush() pour vider le tampon
du clavier si les caractres taps ne satisfont pas
le format auquel s'attend scanf(). Ex.: un "A" avec %d.
Tampon du clavier = stdin.
#include <stdio.h>
#include <conio.h>
void main(void)
{
int a; double b;
clrscr();
printf("\nEntrez un nombre entier: "); scanf("%d", &a); fflush(stdin);
printf("\nEntrez un nombre rel : "); scanf("%lf", &b); fflush(stdin);
printf("\n\nLa valeur de a est: %d", a);
printf("\nLa valeur de b est: %.2f\n\n", b);
La Figure 3 -10 donne un exemple de fonctionnement avec des valeurs numriques conformes au
format utilis par scanf().
F I G U R E 3- 10: E X C U T I ON
DE
T S T S C AN F.E X E
AVE C D E S VAL E U R S P E R M I S E S
la Figure 3 -11, par contre, les valeurs tapes n'ont pas de sens mais fflush() empche scanf() de
faire planter le programme.
F I G U R E 3-11: E X C U T I O N
DE
T S T S C ANF.E X E
AVE C D E S VAL E U R S I N T E R D I T E S
F ON C T I O N S U T I L E S
Description
efface la fin de la ligne partir de la position du curseur.
efface l'cran.
dlai avec une rsolution de 1msec.
limine une ligne en remontant le texte qui suit.
termine un programme ailleurs qu' l'accolade fermant main().
nettoie le tampon du clavier.
lit un caractre du clavier sans cho l'cran.
lit un caractre du clavier avec cho l'cran.
dplace le curseur l'cran entre (1,1) et (80,25).
insre une ligne vierge l'cran en repoussant le texte qui suit.
signale qu'une touche du clavier a t enfonce sans vider le tampon du clavier; utilisez getch()
ou getche() pour le vider.
crit avec format l'cran, du texte et/ou des valeurs de variables.
crit un caractre l'cran (\n = retour de chariot seulement).
crit un caractre l'cran (\n = retour de chariot et aller la ligne comme dans printf()).
fait l'acquisition par le clavier de texte et/ou de valeurs de variables.
dlai avec une rsolution de 1sec.
calcule la longueur d'une chane de caractres.
convertit les caractres en minuscules.
convertit les caractres en majuscules.
donne la position horizontale du curseur.
donne la position verticale du curseur.