CH03_13T

Rsum de Thorie

COMMENTAIRES \* FUSIONFORMAT Cours 13T

SUJET \* FUSIONFORMAT Langage C et Gestion des Entres/Sorties

TITRE \* FUSIONFORMAT Rsum de Thorie

Version prliminaire

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 HEURE \@ "j MMMM aaaa" 1er avril 1996

NOMFICHIER \* FUSIONFORMAT CH03_13T.DOC

TABLE DES MATIRES

TM \o "1-3" 3. Manipulation de donnes en C BOUTONATTEINDRE _Toc352989724 RENVOIPAGE _Toc352989724 3-1

3.1 Constantes BOUTONATTEINDRE _Toc352989725 RENVOIPAGE _Toc352989725 3-1

3.1.1 Types de constantes BOUTONATTEINDRE _Toc352989726 RENVOIPAGE _Toc352989726 3-1

3.1.2 Affichage des constantes avec printf() BOUTONATTEINDRE _Toc352989727 RENVOIPAGE _Toc352989727 3-2

3.2 Variables BOUTONATTEINDRE _Toc352989728 RENVOIPAGE _Toc352989728 3-4

3.2.1 Qu'est-ce qu'une variable? BOUTONATTEINDRE _Toc352989729 RENVOIPAGE _Toc352989729 3-4

3.2.2 Classification des types de donnes BOUTONATTEINDRE _Toc352989730 RENVOIPAGE _Toc352989730 3-4

3.2.3 Identificateur d'une variable BOUTONATTEINDRE _Toc352989731 RENVOIPAGE _Toc352989731 3-5

3.2.4 Dfinition d'une variable BOUTONATTEINDRE _Toc352989732 RENVOIPAGE _Toc352989732 3-6

3.2.5 Affichage des variables avec printf() BOUTONATTEINDRE _Toc352989733 RENVOIPAGE _Toc352989733 3-6

3.2.6 Reprsentation d'une variable en mmoire BOUTONATTEINDRE _Toc352989734 RENVOIPAGE _Toc352989734 3-8

3.3 Oprateurs BOUTONATTEINDRE _Toc352989735 RENVOIPAGE _Toc352989735 3-9

3.3.1 Classification et description BOUTONATTEINDRE _Toc352989736 RENVOIPAGE _Toc352989736 3-9

3.3.2 Niveau de priorit des oprateurs BOUTONATTEINDRE _Toc352989737 RENVOIPAGE _Toc352989737 3-9

3.3.3 Oprations arithmtiques sur des entiers BOUTONATTEINDRE _Toc352989738 RENVOIPAGE _Toc352989738 3-12

3.4 Fonctions de sortie de donnes l'cran BOUTONATTEINDRE _Toc352989739 RENVOIPAGE _Toc352989739 3-13

3.4.1 Fonction printf() BOUTONATTEINDRE _Toc352989740 RENVOIPAGE _Toc352989740 3-13

3.4.2 Fonction putch() BOUTONATTEINDRE _Toc352989741 RENVOIPAGE _Toc352989741 3-13

3.4.3 Fonction puts() BOUTONATTEINDRE _Toc352989742 RENVOIPAGE _Toc352989742 3-14

3.5 Fonctions d'entre de donnes au clavier BOUTONATTEINDRE _Toc352989743 RENVOIPAGE _Toc352989743 3-15

3.5.1 Fonction getch() BOUTONATTEINDRE _Toc352989744 RENVOIPAGE _Toc352989744 3-15

3.5.2 Fonction getche() BOUTONATTEINDRE _Toc352989745 RENVOIPAGE _Toc352989745 3-16

3.5.3 Fonction kbhit() BOUTONATTEINDRE _Toc352989746 RENVOIPAGE _Toc352989746 3-16

3.5.4 Fonction scanf() BOUTONATTEINDRE _Toc352989747 RENVOIPAGE _Toc352989747 3-18

3.6 Quelques fonctions utiles BOUTONATTEINDRE _Toc352989748 RENVOIPAGE _Toc352989748 3-19

Manipulation de donnes en C

Constantes

Types de constantes

Le RENV _Ref349725273 \* FUSIONFORMAT Tableau 3-1 prsente les trois types de constantes du langage C: les constantes entires, relles et caractres.

Tableau REFSTYLE 1 \n 3- SEQ Tableau \* ARABE \r 1 1: Les constantesTypeDescriptionExemplesDcimale68, -31, 2345, 2345LEntire, entire longueOctale015, 0, 077, 077LHexadcimale0x15, 0xFFFF, 0x9A2BLRelleDcimale0.12e2, 1.2e3, 12e-6, -3.1Imprimablea, (, 8, G

Caractre

Non-imprimable\0, \\, \xFD, \137

\a:sonnerie

\b:espacement arrire

\f:saut de page

\n:interligne

\r:retour de chariot

\t:tabulation horizontale

\v:tabulation verticale

\\:oblique inverse

\(:guillemets

\(:apostrophe

\0:nul

\ccc:caractre de valeur octale cc (\000 \377)

\xcc:caractre de valeur hexadcimale cc (\x00 \xFF)Chane(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 non-imprimables 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: CONST.C

* ========= =======

*

* Auteur: Robert Pesant

* Date: 08/10/1992

* Rvision: 08/10/1992

* Version: V1.0

*

* Volume: COURS_13T

* Fichier: \CHAP.003\CONST.C

*

* Description: Affichage des diffrents types de constantes

* l'aide de la fonction printf()

*/

#include

#include

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 RENV _Ref349725573 \* FUSIONFORMAT Figure 3-1 prsente le rsultat de l'excution de CONST.EXE.

Affichage de constantes enti(res en d(cimal et en hexad(cimal.

La premi(re constante enti(re est: 356.

Les deuxi(me et troisi(me constantes enti(res sont: 12 et -45.

Les deuxi(me et troisi(me constantes enti(res sont: c et ffd3.

Les deuxi(me et troisi(me constantes enti(res sont: C et FFD3.

Affichage de constantes r(elles.

La premi(re constante r(elle est: 567.370000.

La deuxi(me constante r(elle est: 3.454720e+03.

Affichage de constantes caract(re.

La premi(re constante caract(re est: a.

La premi(re cha(ne de caract(res est: All(!, comment (a va?.

Une touche pour quitter...

Figure REFSTYLE 1 \n 3- SEQ Figure \* ARABE \r 1 1: Excution de CONST.EXE

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 RENV _Ref349725294 \* FUSIONFORMAT 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 RENV _Ref349725294 \* FUSIONFORMAT 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.

char, unsigned char:Codes ASCII et registres de 8 bits des cartes d'acquisition de donnes, des ports parallle et srie.

int, unsigned int:Compteurs, variables entires.

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.

Tableau REFSTYLE 1 \n 3- SEQ Tableau \* ARABE 2: Les variablesType simpleVariable et Variable modifieOctetsBitsChamp des valeurs numriqueschar18-128 +127signed char18-128 +127unsigned char180 255int216-32768 +32767short int216-32768 +32767long int432-2147483648 +2147483647Entiresigned int216-32768 +32767unsigned int2160 65535signed short int216-32768 +32767unsigned short int2160 65535signed long int432-2147483648 +2147483647unsigned long int4320 4294967295float432(3.4e-38 (3.4e+38Relledouble864(1.7e-308 (1.7e+308long double1080(3.4e-4932 (3.4e+4932

Type drivVariableVariable modifieOctetsBitsTableau*ne sapplique pas**Structure*ne sapplique pas**Union*ne sapplique pas**Pointeur(adresse)ne sapplique pas216

* 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:

les lettres minuscules de a z, sans accents, ni cdille, ni trma;

les lettres majuscules de A Z;

le caractre de soulignement _;

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:

spcifier le type de donne;

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, []:

% [flags] [width] [.prec] [F|N|h|l|L] type_char

drapeaux de formatage

indicateur de largeur de champ

indicateur de pr(cision

modificateur (un seul au choix)

code de conversion

L'aide de Borland C++ sur printf() rvlera tous les raffinements du format d'impression. En guise d'introduction, le RENV _Ref349725358 \* FUSIONFORMAT Tableau 3-3 prsente quelques exemples simples.

Tableau REFSTYLE 1 \n 3- SEQ Tableau \* ARABE 3: Quelques exemples de format d'impressionValeurFormatAffichageRemarque659%d659

Aucun champ sp(cifi(.659%5d 659

-----Champ total de 5 caract(res avec justification ( droite.-659%5d -659

-----Champ total de 5 caract(res avec justification ( droite et affichage automatique du signe -.659%+5d +659

-----Champ total de 5 caract(res avec justification ( droite et affichage automatique du signe -659%-5d659

-----Champ total de 5 caractres avec justification ( gauche.659%06d000659

------Champ total de 6 caract(res avec justification ( gauche et remplissage par des 0.2.348%f2.348000Aucun champ sp(cifi(. Aucune pr(cision: 6 chiffres apr(s le point par dfaut.2.348%.1f2.3Aucun champ sp(cifi(. Pr(cision: 1 chiffre apr(s le point, majoration automatique.2.348%5.2f 2.35

-----Champ total: 5 chiffres incluant le point. Pr(cision: 2 chiffres apr(s le point, majoration automatique.

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

/* Programme: FORMAT.C

* ========= ========

*


* Date: 11/10/1992

* Rvision: 11/10/1992

* Version: V1.0

*

* Volume: COURS_13T

* Fichier: \CHAP.003\FORMAT.C

*

* Description: 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

#include

void main(void)

{

char c = 'A';

int i = 654;

double x = 172.5678;

clrscr();

printf("La variable caractre 'c'= \n\n", c, c, c, c, c, c);

printf("La variable entire 'i'= \n\n", i, i, i, i, i);

printf("La variable relle 'x'= \n\n", x, x, x);

printf("La variable relle 'x'= \n\n", x, x, x ,x);

}

Les rsultats de l'excution de FORMAT.EXE sont prsents la RENV _Ref349725608 \* FUSIONFORMAT Figure 3-2.

La variable caract(re 'c'= < 65>

La variable enti(re 'i'= < 654>

La variable r(elle 'x'= < 173>

La variable r(elle 'x'= < 1.7e+02> < 1.73e+02>

Figure REFSTYLE 1 \n 3- SEQ Figure \* ARABE 2: Excution de FORMAT.EXE

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 RENV _Ref349725629 \* FUSIONFORMAT 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.

FFEF variable

a

FFEE variable

a

FFED

5 FFEC valeur FFEC 5

adresse FFEB

&a a

FFEA ("lvalue" ("rvalue"

= adresse) = valeur)

Mod(le #1 Mod(le #2

Figure REFSTYLE 1 \n 3- SEQ Figure \* ARABE 3: Reprsentation d'une variable en mmoire

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 RENV _Ref349725294 \* FUSIONFORMAT Tableau 3-2.

/* Programme: ADR&DATA.C

* ========= ==========

*


* Date: 12/07/1993

* Rvision: 12/07/1993

* Version: V1.0

*

* Volume: COURS_13T

* Fichier: \CHAP.003\ADR&DATA.C

*

* Description: Ce programme imprime les adresses et les valeurs

* de variables de diffrents types.

*/

#include

#include

void main(void)

{

char var_char = 'A'; /* char: 1 byte, 8 bits */

char var_char1 = 'B'; /* char: 1 byte, 8 bits */

int var_int = 359; /* short int, int: 2 bytes, 16 bits */

int var_int1 = 644; /* short int, int: 2 bytes, 16 bits */

float var_float = 359.0; /* float: 4 bytes, 32 bits */

double var_double = 359.0; /* double: 8 bytes, 64 bits */

char var_char2 = 'C'; /* char: 1 byte, 8 bits */

char var_char3 = 'D'; /* char: 1 byte, 8 bits */

int var_int2 = 888; /* short int, int: 2 bytes, 16 bits */

clrscr();

printf("ADRESSES ET VALEURS DE VARIABLES DE DIFFERENTS TYPES\n");

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

printf(" Adresse Valeur\n");

printf(" ------- ------\n\n");

printf("var_char ...: $%p %c\n", &var_char, var_char );

printf("var_char1 ..: $%p %c\n", &var_char1, var_char1 );

printf("var_int ....: $%p %d\n", &var_int, var_int );

printf("var_int1 ...: $%p %d\n", &var_int1, var_int1 );

printf("var_float ..: $%p %.1f\n", &var_float, var_float );

printf("var_double .: $%p %.1f\n", &var_double, var_double );



printf("var_int2 ...: $%p %d\n", &var_int2, var_int2 );

printf("\n\nFin du programme\n\n\n");

}

La RENV _Ref349725646 \* FUSIONFORMAT Figure 3-4 montre la saisie de lcran aprs lexcution du programme.

ADRESSES ET VALEURS DE VARIABLES DE DIFFERENTS TYPES

====================================================

Adresse Valeur

------- ------

var_char ...: $FFF5 A

var_char1 ..: $FFF4 B

var_int ....: $FFF2 359

var_int1 ...: $FFF0 644

var_float ..: $FFEC 359.0

var_double .: $FFE4 359.0

var_char2 ..: $FFE3 C

var_char3 ..: $FFE2 D

var_int2 ...: $FFE0 888

Fin du programme

A:\>

Figure REFSTYLE 1 \n 3- SEQ Figure \* ARABE 4: Excution de ADR&DATA.EXE

Oprateurs

Classification et description

Un oprateur est un symbole qui reprsente une opration effectuer sur un ou plusieurs oprandes. Le RENV _Ref349725436 \* FUSIONFORMAT 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 RENV _Ref349725456 \* FUSIONFORMAT Tableau 3-5.

Tableau REFSTYLE 1 \n 3- SEQ Tableau \* ARABE 4: Les oprateurs

Oprateurs arithmtiquesFonctionSymboleRemarquesAddition+Soustraction-Multiplication*Division/Modulo%Reste dune division entre entiers: 7/5 = 1, reste 2; donc 7%5 = 2

Oprateurs de manipulation de bitsFonctionSymboleRemarquesET&c = a & b; --> si a = 1001 0011 et b = 0101 0110, c = 0001 0010OU|c = a | b; --> si a = 1001 0011 et b = 0101 0110, c = 1101 0111OU exclusif^c = a ^ b; --> si a = 1001 0011 et b = 0101 0110, c = 1100 0101Dcalage droite>>(a>>2) dcale la valeur de a de 2 bits vers la droiteDcalage gauche b = b + 1 aprs excution de l'instruction

c = a + (++b); --> b = b + 1 avant excution de l'instructionDcrmentattion--c = a + (b--); --> b = b - 1 aprs excution de l'instruction

c = a + (--b); --> b = b - 1 avant excution de l'instructionConversion explicite(nomType)char a; int b; b = (int)a; --> une copie de la valeur de a est transforme en int avant d'tre dpose dans bAdressage indirect**ptr = a; --> copie la valeur de a l'adresse pointe par ptrAdresse de&&a est l'adresse de avalue grandeur mmoiresizeofsizeof(expr),sizeof(nomType)Plus unaire+force l'valuation d'une expression avant une autre cause de son niveau de prioritMoins unaire--a est le complment 2 de aNote: 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).

Oprateurs primairesFonctionSymboleRemarquesParenthse( )Expression dindice[ ]char tableau[8]; tableau[3] = a + tableau[5];Slecteur de membre->slection par pointeur: ptrstruct->mois = 12;Slecteur de membre.slection par la structure: date.mois = 12;

Tableau REFSTYLE 1 \n 3- SEQ Tableau \* ARABE 5: Priorit des oprateursNiveau de prioritType doprateurOp(rateursAssociativit(15Primaire( )[ ].->--->14Unaire++--(nomType)*&sizeof+-!~ 12Arithmtique+---->11De manipulation de bits>>=9De relation==!=--->8De manipulation de bits&--->7De manipulation de bits^--->6De manipulation de bits|--->5Logique&&--->4Logique||--->3Conditionnel?:--->2D'affectation=+=-=*=/=%=|=^=&=>>=

Figure REFSTYLE 1 \n 3- SEQ Figure \* ARABE 7: Excution 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 mot-cl 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: TSTGETCH.C

* ========= ==========

*


* Date: 18/02/1990

* Rvision: 09/04/1995

* Version: V2.1

*

* Volume: COURS_13T

* Fichier: \CHAP.003\TSTGETCH.C

*

* Description: Essai de la fonction getch().

*/

#include

#include

void main(void)

{

int c = 0;

clrscr();

printf("Appuyez sur une touche. Faites pour quitter.\n\n");

while(c != 27)

{

c = getch();

putch(c); putch('\n'); putch('\r');

}

printf("\nFin!\a");

}

La RENV _Ref350405021 \* FUSIONFORMAT Figure 3-8 montre un exemple typique de sortie l'cran que peut produire l'excution du programme.

Appuyez sur une touche. Faites pour quitter.

w

W

4

5

n

(

Fin!

A:\>

Figure REFSTYLE 1 \n 3- SEQ Figure \* ARABE 8: Excution 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: TSGETCHE.C

* ========= ==========

*


* Date: 18/02/1990

* Rvision: 09/04/1995

* Version: V2.1

*

* Volume: COURS_13T

* Fichier: \CHAP.003\TSGETCHE.C

*

* Description: Essai de la fonction getche().

*/

#include

#include

void main(void)

{

int c = 0;

clrscr();

printf("Appuyez sur une touche. Faites 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 RENV _Ref350405041 \* FUSIONFORMAT Tableau 3-6, en fonction de l'tat du tampon du clavier.

Tableau REFSTYLE 1 \n 3- SEQ Tableau \* ARABE 6:Fonctionnement de kbhit()Tampon du clavier Valeur numrique retourne (Type de donne = int)tat logiqueVideZro0, FAUXNon videDiffrente de zro1, 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 RENV _Ref350405041 \* FUSIONFORMAT 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: TSTKBHIT.C

* ========= ==========

*


* Date: 18/02/1990

* Rvision: 04/08/1991

* Version: V1.1

*

* Volume: COURS_13T

* Fichier: \CHAP.003\TSTKBHIT.C

*

* Description: Essai de la fonction kbhit().

*/

#include

#include

#include

#include

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. RENV _Ref350405106 \* FUSIONFORMAT Figure 3-9).

CHRONOMETRE

***********

6 secondes

Fin!

A:\>

Figure REFSTYLE 1 \n 3- SEQ Figure \* ARABE 9: Excution de TSTKBHIT.EXE

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 RENV _Ref350405129 \* FUSIONFORMAT Tableau 3-7.

Tableau REFSTYLE 1 \n 3- SEQ Tableau \* ARABE 7: Usage limit de scanf()Type de la valeur numrique entre au clavierDfinition de la variable affecteUsage limit de scanf()entier dcimalint a;scanf((%d(, &a);entier hexadcimalunsigned int b;scanf((%x(, &b);rel dcimaldouble c;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: TSTSCANF.C

* ========= ==========

*


* Date: 28/09/1992

* Rvision: 12/10/1992

* Version: V2.0

*

* Volume: COURS_13T

* Fichier: \CHAP.003\TSTSCANF.C

*

* Description: 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

#include

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 RENV _Ref349725763 \* FUSIONFORMAT Figure 3-10 donne un exemple de fonctionnement avec des valeurs numriques conformes au format utilis par scanf().

Entrez un nombre entier: 123

Entrez un nombre r(el : 67.456

La valeur de a est: 123

La valeur de b est: 67.46

Figure REFSTYLE 1 \n 3- SEQ Figure \* ARABE 10: Excution de TSTSCANF.EXE avec des valeurs permises

la RENV _Ref349725775 \* FUSIONFORMAT Figure 3-11, par contre, les valeurs tapes n'ont pas de sens mais fflush() empche scanf() de faire planter le programme.

Entrez un nombre entier: 56py7

Entrez un nombre r(el : 3a.89sr

La valeur de a est: 56

La valeur de b est: 3.00

Figure REFSTYLE 1 \n 3- SEQ Figure \* ARABE 11: Excution de TSTSCANF.EXE avec des valeurs interdites

Quelques fonctions utiles

Consultez le RENV _Ref349725203 \* FUSIONFORMAT Tableau 3-8.

Tableau REFSTYLE 1 \n 3- SEQ Tableau \* ARABE 8: Quelques fonctions utilesFonctionDescriptionclreol()efface la fin de la ligne partir de la position du curseur.clrscr()efface l'cran.delay()dlai avec une rsolution de 1msec.delline()limine une ligne en remontant le texte qui suit.exit()termine un programme ailleurs qu' l'accolade fermant main().fflush()nettoie le tampon du clavier.getch()lit un caractre du clavier sans cho l'cran.getche()lit un caractre du clavier avec cho l'cran.gotoxy()dplace le curseur l'cran entre (1,1) et (80,25).insline()insre une ligne vierge l'cran en repoussant le texte qui suit.kbhit()signale qu'une touche du clavier a t enfonce sans vider le tampon du clavier; utilisez getch() ou getche() pour le vider.printf()crit avec format l'cran, du texte et/ou des valeurs de variables.putch()crit un caractre l'cran (\n = retour de chariot seulement).putchar()crit un caractre l'cran (\n = retour de chariot et aller la ligne comme dans printf()).scanf()fait l'acquisition par le clavier de texte et/ou de valeurs de variables.sleep()dlai avec une rsolution de 1sec.strlen()calcule la longueur d'une chane de caractres.tolower()convertit les caractres en minuscules.toupper()convertit les caractres en majuscules.wherex()donne la position horizontale du curseur.wherey()donne la position verticale du curseur.

TITRE \* FUSIONFORMAT Rsum de Thorie SUJET \* FUSIONFORMAT Langage C et Gestion des Entres/Sorties

MOTSCLES \* FUSIONFORMAT Manipulation de donnes en CPage PAGE \* FUSIONFORMAT iiiOFPPT/TECCART

INCORPORER CDraw4

Royaume du Maroc

OFFICE DE LA FORMATION PROFESSIONNELLE ET DE LA PROMOTION DU TRAVAIL

Deuxime Anne

Programme de Formation des Techniciens

Spcialiss en lectronique

DIRECTION DE LA RECHERCHE ET INGENIERIE DE LA FORMATION

Septembre 1996

Documents

CH03_13T