Vous êtes sur la page 1sur 24

Royaume du Maroc

OFFICE DE LA FORMATION PROFESSIONNELLE ET DE LA PROMOTION DU TRAVAIL

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

Langage C et Gestion des Entres/Sorties

TECCART INTERNATIONAL 2000 inc.


3155, rue Hochelaga,
Montral, Qubec (Canada)
H1W 1G4

RDACTION
Robert Pesant
DESSINS ET CONCEPTION GRAPHIQUE
Robert Pesant
RVISION TECHNIQUE
Robert Pesant
RVISION LINGUISTIQUE
Franois Gaudreau

COMMISSION DE VALIDATION
Formateurs de lOFPPT

Les droits de reproduction et de diffusion de ce document sont cds par Teccart


International 2000 inc. lOffice de la Formation Professionnelle et de la Promotion du
Travail du Royaume du Maroc, pour sa propre utilisation au Maroc.
Mis part lOFPPT, toute reproduction, en tout ou en partie, par quelque procd que ce
soit, est interdite.

Imprim Montral, le j May


270915092.doc

Manipulation de donnes en C

Page ii

OFPPT/TECCART

Rsum de Thorie

Langage C et Gestion des Entres/Sorties

TABLE DES MATIRES


3. MANIPULATION DE DONNES EN C
03.1 Constantes
03.1.1 Types de constantes....................................................................................................
13.1.2 Affichage des constantes avec printf()........................................................................
13.2 Variables
23.2.1 Qu'est-ce qu'une variable?..........................................................................................
33.2.2 Classification des types de donnes............................................................................
43.2.3 Identificateur d'une variable........................................................................................
53.2.4 Dfinition d'une variable.............................................................................................
63.2.5 Affichage des variables avec printf()...........................................................................
73.2.6 Reprsentation d'une variable en mmoire.................................................................
23.3 Oprateurs
83.3.1 Classification et description........................................................................................
93.3.2 Niveau de priorit des oprateurs...............................................................................
103.3.3 Oprations arithmtiques sur des entiers..................................................................
33.4 Fonctions de sortie de donnes l'cran
113.4.1 Fonction printf().......................................................................................................
123.4.2 Fonction putch().......................................................................................................
133.4.3 Fonction puts().........................................................................................................
43.5 Fonctions d'entre de donnes au clavier
143.5.1 Fonction getch().......................................................................................................
153.5.2 Fonction getche()......................................................................................................
163.5.3 Fonction kbhit()........................................................................................................
173.5.4 Fonction scanf().......................................................................................................
53.6 Quelques fonctions utiles

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?".

Affichage des constantes avec printf()


L'appel de cette fonction de la bibliothque de Borland C++ s'effectue de la faon gnrale
suivante:
printf("chane formate", liste d'arguments afficher); .
La "chane formate" est une chane de caractres imprimables et/ou non-imprimables
accompagns de codes spcifiant le format d'impression des arguments. Voici un exemple de
"chane formate":
"Les deuxime et troisime constantes entires sont: %d et %d." .
Le format minimum d'impression est constitu du caractre % suivi d'un code de conversion, dont
voici les principaux:
d: entier affich en dcimal;
x: entier affich en hexadcimal avec lettre minuscule;
X: entier affich en hexadcimal avec lettre majuscule;
f: rel affich en notation conventionnelle (ex.: 112.34);
e: rel affich en notation scientifique (ex.: 1.1234e2);
c: caractre;
s: chane de caractres;
p: pointeur en hexadcimal (ex.: FFA3);
%: le caractre % (cas particulier: %% pour afficher %).
Les arguments afficher peuvent tre des constantes ou des variables spares par des virgules.
L'exemple qui suit ne contient que des constantes:
12, -45
Il doit y avoir autant de codes de format d'impression qu'il y a d'arguments dans la liste. Dans
l'nonc qui suit, la constante 12 est associe au premier %d et la constante -45, au deuxime %d:
printf("Les deuxime et troisime constantes entires sont: %d et %d.", 12, -45);
Le texte affich l'cran par cette instruction est:
Les deuxime et troisime constantes sont: 12 et -45.
On constate que les arguments sont insrs dans le texte la place des codes de format d'impression
selon l'ordre suivant: le premier code avec le premier argument; le deuxime code avec le deuxime
argument; et ainsi de suite. Si le nombre de codes de format d'impression ne correspond pas au
nombre d'arguments, le programme se comportera de faon bizarre, s'il ne plante pas
dfinitivement.
Pour comprendre et utiliser correctement ces codes de conversion, examinez attentivement le
listage du programme CONST.C.

/* 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...");

/* Attend que l'usager appuie sur une touche */


getch();

La Figure 3 -1 prsente le rsultat de l'excution de CONST.EXE.

F I G U R E 3-1: E X C U T I ON

DE

CO NS T.E X E

Analysons la ligne de programme suivante:


printf("Les deuxime et troisime constantes entires sont: %d et %d.\n", 12, -45);
On reconnat l'nonc analys prcdemment avec en ajout le caractre non-imprimable \n la fin
de la chane formate. Aprs avoir affich cette chane de caractres en remplaant les codes de
format d'impression par les constantes de la liste des arguments, printf() positionnera le curseur
au dbut de la ligne suivante l'cran: afficher le caractre non-imprimable \n quivaut
effectuer un changement de ligne accompagn d'un retour de chariot.

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

Champ des valeurs numriques

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

* Indtermin. a dpend de la dfinition individuelle de chaque variable. Il y aura, par


exemple, des tableaux de variables de type int ainsi que des tableaux de variables de type double.

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.

Dfinition d'une variable


Dans un programme, pour que le compilateur rserve l'emplacement mmoire ncessaire pour
stocker les valeurs des variables, on doit toujours dfinir ces dernires avant de les utiliser.
Pour dfinir une variable, on doit:
8.
spcifier le type de donne;
9.
indiquer l'identificateur de la variable.
La dfinition des variables s'effectue au dbut du bloc de la fonction, avant la premire
instruction. Une variable peut tre initialise lors de sa dfinition. En voici des exemples.
int acquisition(void)
{
unsigned char input;......Dfinition de input: type unsigned char, 1 octet.
int i, j, k;..........................Dfinition simultane de i, j, k: type int, 2 octets par variable.
int limite_sup = 125;......Dfinition et affectation de limite_sup: type int, 2 octets.
i = limite_sup;.................Premire instruction.
...
}
Affichage des variables avec printf()
Plus tt dans ce chapitre, vous avez vu comment faire l'appel de printf() pour afficher des
constantes. Vous devez procder de la mme manire pour les variables:
printf("chane formate", liste d'arguments afficher); .
La liste d'arguments afficher sera maintenant compose de variables spares par une virgule.
chaque variable de la liste doit correspondre un code de format d'impression dans la "chane
formate".
Pour afficher d'une faon plus soigne les valeurs des variables, vous devez utiliser des formats
d'impression plus complets que ceux qui ont t expriments jusqu' maintenant.
Le format d'impression complet, dcrit dans l'aide de Borland C++ sur printf(), est constitu
d'lments obligatoires, le caractre % et les codes de conversion (d, c, f, ...), et d'lments
optionnels prsents entre crochets, []:

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

Champ total de 5 caractres avec justification droite.


Champ total de 5 caractres avec justification droite et affichage
automatique du signe - .
Champ total de 5 caractres avec justification droite et affichage
automatique du signe -
Champ total de 5 caractres avec justification gauche.
Champ total de 6 caractres avec justification gauche et remplissage
par des 0 .
Aucun champ spcifi. Aucune prcision: 6 chiffres aprs le point par
dfaut.
Aucun champ spcifi. Prcision: 1 chiffre aprs le point, majoration
automatique.
Champ total: 5 chiffres incluant le point. Prcision: 2 chiffres aprs le
point, majoration automatique.

Le programme FORMAT.C donne d'autres exemples de format dimpression avec printf().


/* Programme:
* =========
*
* Auteur:
* Date:
* Rvision:
* Version:
*
* Volume:
* Fichier:
*
* Description:
*
*
*
*/

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>

<%4d> <%-4d> <%04d> <$%X> <%c>\n\n", c, c, c, c, c, c);


<%4d> <%-4d> <%04d> <$%04X>\n\n", i, i, i, i, i);
<%4.0f> <%5.1f>\n\n", x, x, x);
<%9.1e> <%9.2e> <%9.3e>\n\n", x, x, x ,x);

Les rsultats de l'excution de FORMAT.EXE sont prsents la Figure 3 -2.

F I G U R E 3-2: E X C U T I ON

DE

F O R MAT.E X E

Reprsentation d'une variable en mmoire


Une variable est dcrite par son adresse et sa valeur. En C, on utilise aussi l'occasion valeur
gauche pour l'adresse d'une variable et valeur droite pour sa valeur. Certains messages
d'erreurs du compilateur de Borland C++ font mention de lvalue ( left value ) et rvalue
( right value ): il suffira de s'en rappeler.
La valeur d'une variable est toujours reprsente par son identificateur: a est donc la valeur de la
variable dfinie par l'nonc int a;. Par contre, pour spcifier l'adresse de cette variable, on utilise
l'oprateur adresse de , &, devant son identificateur: &a. La Figure 3 -3 prcise ces deux
notions tout en prsentant les deux modles de reprsentation d'une variable en mmoire. Comme
la variable a est de type int, sa valeur numrique 5, reprsente par l'identificateur a, occupe deux
octets de mmoire; son adresse &a est l'adresse la plus basse de la rgion mmoire qu'elle
occupe.





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("ADRESSES ET VALEURS DE VARIABLES DE DIFFERENTS TYPES\n");


printf("====================================================\n\n\n");

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");

La Figure 3 -4 montre la saisie de lcran aprs lexcution du programme.

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

Reste dune division entre entiers: 7/5 = 1, reste 2; donc 7%5 = 2

Oprateurs de manipulation de bits


Fonction
Symbole Remarques
ET
&
c = a & b; --> si a = 1001 0011 et b = 0101 0110, c = 0001 0010
OU
|
c = a | b; --> si a = 1001 0011 et b = 0101 0110, c = 1101 0111
OU exclusif
^
c = a ^ b; --> si a = 1001 0011 et b = 0101 0110, c = 1100 0101
Dcalage droite
>>
(a>>2) dcale la valeur de a de 2 bits vers la droite
Dcalage gauche
<<
(a<<2) dcale la valeur de a de 2 bits vers la gauche
Complment un
c = ~a --> si a = 1001 0011, c = 0110 1100

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.

Oprateurs dvaluation squentielle


Fonction
Symbole Remarques
valuation squentielle
,
int a, b;

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

>= <=

-= *= /= %=

|=

^= &= >>=<<=

--->
<----->
--->
--->
--->
--->
--->
--->
--->
--->
--->
--->
<----->

Oprations arithmtiques sur des entiers


Lorsque des variables de type int font partie d'expressions contenant des oprateurs
arithmtiques, il arrive parfois que cela engendre des erreurs de calcul. Cela rsulte du fait qu'un
entier n'a pas de partie fractionnaire.
Si la dfinition d'une variable est int a; et que a = 9;, alors l'expression (a/4) vaut 2 et non 2.25.
Pour viter cette erreur, le calcul se doit d'tre effectu avec des valeurs de type double.
Une premire solution consiste utiliser une constante relle pour forcer le compilateur
transformer aussi en double la valeur de la variable avant d'effectuer l'opration: (a/4.0).
La deuxime solution utilise l'oprateur de conversion explicite (nomType): ((double)a/4). Le
compilateur sera forc d'utiliser une version double de la valeur de a avant de procder au calcul.
Cette mthode est surtout utilise lorsque l'expression ne comporte pas de constante.
Le programme NOMTYPE.C dmontre ces techniques et la Figure 3 -5 prsente les rsultats
obtenus.
/* Programme:
* =========
*
* Auteur:
* Date:
* Rvision:
* Version:
*
* Volume:
* Fichier:
*
* Description:
*
*/

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

Fonctions de sortie de donnes l'cran


Fonction printf()
Cette fonction a t analyse en dtail pour afficher les constantes et les variables. Nous ne
donnerons pas d'exemples supplmentaires.
Fonction putch()
La fonction putch() affiche l'cran un seul caractre la fois. Toutefois, contrairement la
fonction printf(), le caractre non-imprimable "\n" est interprt comme un changement de ligne
seulement. L'instruction putch('\r'); est ncessaire pour effectuer un retour de chariot.
/* Programme:
* =========
*
* Auteur:
* Date:
* Rvision:
* Version:
*
* Volume:
* Fichier:
*
* Description:
*/

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");

La Figure 3 -6 montre les rsultats obtenus lexcution du programme.

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");
}

Excutez le programme TESTPUTS.C et vous obtiendrez le rsultat de la Figure 3 -7.

F I G U R E 3- 7: E X C U T I O N

DE

TESTPUTS.EXE

Fonctions d'entre de donnes au clavier


Fonction getch()
La fonction getch() attend que l'usager appuie sur une touche pour retourner le code ASCII de
celle-ci et vider le tampon ("buffer") du clavier.
Dans le programme qui suit, le code ASCII de la touche est dtect par l'nonc c = getch(); et
est affich par putch(c);. Cette squence est rpte par une boucle while jusqu' ce que l'usager
appuie sur Esc (code ASCII = 27). L'tude dtaille des boucles sera le sujet du prochain
chapitre.
L'aide de Borland C++ rvle que le prototype de fonction de getch() est int getch(void). Le
type de donne void, crit entre les parenthses, indique que cette fonction ne ncessite aucun
paramtre: c'est pour cela que l'appel de getch() se fait avec rien entre les parenthses. Le motcl int, plac devant l'identificateur de la fonction, prcise le type de donne utilis pour retourner
le code ASCII de la touche dtecte; pour stocker cette valeur de 16 bits, vous conviendrez qu'il
tait logique d'utiliser une variable de 16 bits galement; la variable c a donc t dfinie avec le
mme type de donne: int c = 0;.
/* Programme:
* =========
*
* Auteur:
* Date:
* Rvision:
* Version:
*
* Volume:
* Fichier:
*
* Description:
*/

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 ()

Valeur numrique retourne (Type de donne = int)


Zro
Diffrente de zro

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 ()

Dfinition de la variable affecte

Usage limit de scanf()

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

Quelques fonctions utiles


Consultez le Tableau 3 -8.
T AB L E AU 3-8: Q U E L QU E S
Fonction
clreol()
clrscr()
delay()
delline()
exit()
fflush()
getch()
getche()
gotoxy()
insline()
kbhit()
printf()
putch()
putchar()
scanf()
sleep()
strlen()
tolower()
toupper()
wherex()
wherey()

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.