Vous êtes sur la page 1sur 19

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 20 mai 2015


270915123.doc

Prises de dcisions et boucles

Page 2

OFPPT/TECCART

Rsum de Thorie

Langage C et Gestion des Entres/Sorties

TABLE DES MATIRES


4. PRISES DE DCISIONS ET BOUCLES
04.1 Types d'instructions en C
14.2 Prises de dcisions
04.2.1 Instruction slective if
14.2.2 Instruction slective if...else
24.2.3 Instruction slective avec l'oprateur conditionnel ? :
34.2.4 Instruction slective switch...case
24.3 Boucles
44.3.1 Instruction itrative do...while
54.3.2 Instruction itrative while
64.3.3 Instruction itrative for

Prises de dcisions et boucles

Page 3

OFPPT/TECCART

Prises de dcisions et boucles


Types d'instructions en C
Une instruction est une structure de contrle qui dtermine le cheminement logique d'un
programme. Le Tableau 4 -1 prsente les six catgories d'instructions en C. Dans ce chapitre, la
discussion portera exclusivement sur les instructions slectives ou prises de dcisions et sur les
instructions itratives ou boucles.
T AB L E AU 4-1: C AT G O R I E S
Catgories dinstructions
Instruction construite partir
dun nonc

Mots-cls

Instruction construite avec un


bloc dnoncs

Instructions slectives ou
prises de dcisions

Instructions itratives ou
boucles
Instructions de contrle

Instruction nulle

if
if ... else
switch ... case
? :
for
while
do ... while
break
return
goto
continue

D ' I N S T R U C T I ON S E N

Exemples et remarques
a = 234; <-------------- initialisation de variable
clrscr(); <-------------- appel de fonction
cel = (far - 32.0)*5.0/9.0; <-- calcul
{
pos_x++;
gotoxy(pos_x, pos_y);
printf("Temprature: %5.1fC\n", t);
}
Les accolades dlimitent un bloc.
Seront analyses dans ce chapitre-ci.
Cas particulier: les signes de ponctuation ?...: sont
appels oprateur conditionnel; il n'y a pas de mot-cl
comme tel.
Seront analyses dans ce chapitre-ci.

break sera analyse avec switch...case.


return termine une fonction et renvoie l'excution du
programme la fonction qui l'a appele. Sera analyse
au chapitre sur les fonctions
goto et continue rendent les programmes illisibles, peu
fiables et trs difficiles dpanner. Il faut absolument
viter de s'en servir!
;
rien! suivi d'un ; ... le programme ne fait rien cette
ligne.

Prises de dcisions
Instruction slective if
Cette premire instruction slective est dcrite la Figure 4 -1. On y prsente la syntaxe
gnrale, valable en tout temps et en toutes circonstances, ainsi que lordinogramme de
fonctionnement.

Syntaxe de if

Ordinogramme de if
Dbut de
if

if(expr)
{
instr_if;
}
Note :
Il peut y avoir plusieurs
instructions dans le
bloc de
if .

valuer
l'expression
expr

expr

== VRAI ?

OUI
NON

Excuter
l'instruction
instr_if

Fin de
if
F I G U R E 4-1: I N S T R U C T I ON

SLECTIVE

IF

Lorsque l'expression situe entre les parenthses de l'instruction if est vraie, le bloc d'instructions
dlimit par les accolades est excut. Puis, le programme passe l'excution de l'instruction
suivante.
Si cette expression est fausse, le programme passe immdiatement l'instruction suivante.

Le programme TESTIF.C dmontre le fonctionnement de cette structure de contrle.


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

TESTIF.C
========
Robert Pesant
02/03/1990
09/04/1995
V2.2
COURS_13T
\CHAP.004\TESTIF.C
Test de l'instruction "if"

#include <stdio.h>
#include <conio.h>
void main(void)
{
int b;
clrscr();
printf("Entrez une valeur pour la variable entire \"b\": ");
scanf("%d", &b); fflush(stdin);

printf("La variable \"b\" est <= 20.");


if(b > 20)
{
gotoxy(21, wherey());
clreol();
printf("> que 20.");
}

L'usager doit entrer une valeur entire qui est affecte la variable b par la fonction scanf().
Par dfaut, la valeur est suppose infrieure ou gale 20. Elle est ensuite teste par l'instruction
if: si elle est rellement infrieure ou gale 20, le bloc d'instructions de if n'est pas excut et le
programme se termine immdiatement.
Par contre, si b > 20 est vraie, le bloc d'instructions de if est excut: le curseur est plac la
position du caractre '<', le reste de la ligne est efface et la chane de caractres "> que 20." est
affiche.
La Figure 4 -2 prsente les rsultats obtenus lors des essais du programme.

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

DE

T E S T I F.E X E

Instruction slective if...else


La Figure 4 -3 dcrit l'instruction slective if...else. La syntaxe gnrale, valable en tout temps et
en toutes circonstances, ainsi que lordinogramme de fonctionnement sont mis en vidence.

Syntaxe de

if...else

Ordinogramme de if...else

if(expr)

Dbut de
if...else

{
instr_if;
}
else

valuer
l'expression
expr

{
instr_else;
}
Note :
Il peut y avoir plusieurs
instructions dans les
blocs de
if et de

else .

expr

== VRAI ?

NON

OUI

Excuter
l'instruction
instr_if

Excuter
l'instruction
instr_else

Fin de
if...else
F I G U R E 4- 3: I N S T R U C T I O N

SLECTIVE

IF... ELSE

Lorsque l'expression situe entre les parenthses de l'instruction if est vraie, le bloc d'instructions
if, dlimit par les accolades, est excut. Puis, le programme passe l'excution des instructions
suivantes, sans excuter les instructions else.
Si cette expression est fausse, le programme excute le bloc d'instructions else avant de passer
aux instructions suivantes.

Pour dmontrer le fonctionnement de l'instruction slective if...else, analysons le programme


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

IFELSE.C
========
Robert Pesant
02/03/1990
07/02/1993
V2.1
COURS_13T
\CHAP.004\IFELSE.C
Test de l'instruction "if ... else"

#include <stdio.h>
#include <conio.h>
void main(void)
{
int b;
clrscr();
printf("Entrez une valeur pour la variable entire \"b\": ");
scanf("%d", &b); fflush(stdin);
printf("La variable \"b\" est ");
if(b%2)
{
printf("impaire\n");
}
else
{
printf("paire\n");
}

printf("Fin!\a\n");
printf("Une touche pour quitter ...");
getch();

On demande encore l'usager de taper une valeur entire qui est dpose dans b par la fonction
scanf(). Plus loin, l'expression b%2 est teste par l'nonc de contrle if...else.
Rappelons que l'oprateur % permet d'valuer le reste de la division entre deux entiers (voir le
tableau sur les oprateurs au chapitre prcdent). Si l'usager tape 7, alors b/2 gale 3 et b%2, le
reste, vaut 1: toute valeur numrique diffrente de 0, lorsque teste, donne un 1 logique ou un
VRAI (voir la note concernant les oprateurs logiques dans le tableau sur les oprateurs au
chapitre prcdent). Dans ce cas, seul le bloc d'instructions du if est excut.
Si l'usager tape 8, alors b/2 gale 4 et b%2, le reste, vaut 0: le test de la valeur numrique 0
donne un 0 logique ou un FAUX; le programme n'excute que le bloc d'instructions else.
Les rsultats de la Figure 4 -4 confirment cette analyse

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

DE

I FE LS E . E X E

Instruction slective avec l'oprateur conditionnel ? :


La Figure 4 -5 dcrit l'utilisation de l'oprateur conditionnel constitu de deux signes de
ponctuation, le ? et le : . Cet oprateur peut remplacer l'instruction slective if...else, dans
le cas d'une affectation conditionnelle de variable.
La syntaxe de cette instruction est d'une concision et d'une lgance remarquables: si l'expression
gauche du point d'interrogation, expr_b, est VRAIE, la variable affecter, expr_a, prend la
valeur de l'expression expr_c, place gauche des deux points; sinon, expr_a prend la valeur de
expr_d, l'expression situe droite des deux points.

Syntaxe de ?:

Ordinogramme de ?:
Dbut de
?:

expr_a = (expr_b) ? expr_c : expr_d;


Note 1

: Oprateur conditionnel:

Note 2

: if...else

?:

valuer
l'expression
expr_b

quivalent:

if(expr_b)
{
expr_a = expr_c;
}

expr_b
VRAI ?

else
{
expr_a = expr_d;
}

==

NON

OUI

expr_a = expr_c

expr_a = expr_d

Fin de
?:
F I G U R E 4- 5: L' OP R ATE U R

C O N D I T I ON N E L

?:

Le programme OP_COND.C demande l'usager d'entrer au clavier une valeur entre 4,00 et 20,0
pour simuler le signal d'un transmetteur 4-20 mA. Notez que ces appareils d'instrumentation ne
produisent pas de courant de sortie infrieur environ 4 mA ni suprieur environ 20 mA.
L'nonc courant = (courant > 20.00) ? 20.0 : courant; limite la valeur maximale entre par
l'usager 20,0 mA. Si l'usager entre une valeur plus grande que 20, la valeur 20.0 est affecte la
variable courant; sinon, la valeur de courant est affecte courant!!! Cela revient dire que sa
valeur n'est pas change.
L'nonc courant = (courant < 4.00) ? 4.0 : courant; fonctionne de la mme faon pour la
limite infrieure de 4,0 mA.

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

OP_COND.C
=========
Robert Pesant
07/02/1993
07/02/1993
V1.0
COURS_13T
\CHAP.004\OP_COND.C
Test de l'oprateur conditionnel "?:"

#include <stdio.h>
#include <conio.h>
void main(void)
{
double courant;
clrscr();
printf("Simulation d'un transmetteur 4-20 mA\n");
printf("====================================\n\n");
printf("Tapez une valeur entre 4.00 et 20.00: ");
scanf("%lf", &courant); fflush(stdin);
courant = (courant > 20.00) ? 20.0 : courant;
courant = (courant < 4.00) ? 4.0 : courant;

printf("Le courant du transmetteur est: %5.2f mA\n\n", courant);


printf("Une touche pour quitter ...");
getch();

La Figure 4 -6 prsente les rsultats obtenus pour diverses valeurs de courant.

F I G U R E 4-6: E X C U T I ON

DE

O P _ CO ND . E X E

Instruction slective switch...case


L'instruction slective switch...case permet de remplacer plusieurs if...else imbriqus lorsqu'il
s'agit d'effectuer un choix multiple. C'est l'nonc de contrle que l'on doit privilgier dans un
programme o le menu offre l'usager plusieurs options. Cette structure de contrle utilise les
mots-cls suivants:
1.
switch: instruction slective pour choix multiple;
2.
case: identification de chaque choix;
3.
break: fin de l'instruction switch...case, aprs lexcution des instructions de l'option utilise;
4.
default: prcise les instructions excuter si le choix de l'usager ne correspond pas un case.
La Figure 4 -7 prsente la syntaxe gnrale ainsi que l'ordinogramme de fonctionnement du
switch...case.
Syntaxe de switch...case
Notes :
- expr doit tre obligatoirement de type
int .
- Il peut y avoir autant de
case que l'on dsire.
- const_a
, const_b
,... doivent obligatoirement tre
des constantes entires.
- Le choix
default
est optionnel.
- Si les
break ne sont pas utiliss ou sont oublis,
les instructions suivantes sont excutes (Voir
l'ordinogramme).

switch(expr)
{
case const_a:
instr_a;
break;
case const_b:
instr_b;
break;
default:
instr_def;
}

Dbut de
switch...case

Ordinogramme de switch...case
valuer
l'expression
expr
NON
NON

( expr
( expr

expr ==
const_b
?

expr ==
const_a
?

!= const_a
!= const_b

OUI

OUI

Excuter
l'instruction
instr_b

Excuter
l'instruction
instr_def

) et
)?

OUI
NON

Excuter
l'instruction
instr_a

break

NON

break

NON

OUI

OUI

F I G U R E 4-7: I N S T R U C T I ON

A
Fin de
switch...case
SLECTIVE

S W I T C H . . . C AS E

Cet nonc de contrle est caractris par une flexibilit remarquable.


5.
On peut dfinir autant de cas (case) que l'on dsire.
6.
Le choix default est optionnel.
7.
Les instructions break; sont optionnelles; toutefois, si le break de case const_a est omis et
que expr == const_a, toutes les instructions seront excutes jusqu'au prochain
break: ici instr_a et instr_b, mais pas default.
Il n'y a qu'une seule restriction switch...case: cette instruction s'applique uniquement des
valeurs de type int. Donc,
8.
expr doit obligatoirement tre de type int, tout comme
9.
const_a, const_b, ...
L'excution de l'instruction slective switch...case dbute par l'valuation de l'expression entre les
parenthses; cette expression est souvent le nom d'une variable.
Si cette expression (ou la variable) est identique la constante d'un case, les instructions de ce
case sont excutes. Si la dernire de ces instructions est break;, alors le programme saute aux
instructions qui suivent switch...case. Si l'instruction break; est omise, les instructions du case
suivant sont aussi excutes. En gnral, on trouve break pour chaque case, mais on verra plus
loin certaines applications o il est avantageux de ne pas l'utiliser.
Si l'expression (ou la variable) est diffrente des constantes de tous les case, on peut utiliser le
mot-cl default pour faire excuter une srie d'instructions pertinentes. Par contre, selon
l'application, l'usager peut liminer le default si son application exige qu'aucune instruction ne
soit excute dans ce cas.
Notez finalement que le dernier choix de switch...case, qu'il soit dfini par un case ou default, ne
ncessite pas de break: cet endroit de l'instruction slective, le programme n'a pas le choix de
poursuivre avec les instructions suivantes.
Excutez SWITCH.C dans sa version intgrale. Puis, observez le comportement du programme
en liminant tour de rle l'option default ainsi que les noncs break;.
La Figure 4 -8 montre la sortie du programme, version intgrale, pour diffrentes valeurs
choisies par l'usager.

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

SWITCH.C
========
Robert Pesant
02/03/1990
01/10/1992
V2.0
COURS_13T
\CHAP.004\SWITCH.C
Test de l'instruction "switch ... case"

#include <stdio.h>
#include <conio.h>
void main(void)
{
int jour;
clrscr();
printf("Entrez le numro d'un jour de la semaine (1 7): ");
scanf("%d", &jour); fflush(stdin);
printf("Le jour #%d de la semaine est le ",jour);
switch(jour)
{
case 1:
printf("DIMANCHE!!!\n");
break;
case 2:
printf("LUNDI!!!\n");
break;
case 3:
printf("MARDI!!!\n");
break;
case 4:
printf("MERCREDI!!!\n");
break;
case 5:
printf("JEUDI!!!\n");
break;
case 6:
printf("VENDREDI!!!\n");
break;
case 7:
printf("SAMEDI!!!\n");
break;
default:
printf("... Petit drle, va!!!\n");
}
}

printf("Fin!\a");

F I G U R E 4-8: E X C U T I ON

DE

S W I T CH . E X E

Boucles
Instruction itrative do...while
Cette premire instruction itrative est dcrite par un ordinogramme la Figure . On y prsente
galement la syntaxe dans sa forme la plus gnrale.

Syntaxe de do...while

Ordinogramme de do...while

do

Dbut de
do...while

{
instr;
}
while(expr);

Excuter
l'instruction
instr

Note :
Le bloc d'instructions de
do...while
est excut au
moins une fois, car le test
de expr s'effectue la fin
de la boucle.

valuer
l'expression
expr

OUI

expr

== VRAI ?

NON

Fin de
do...while
F I G U R E 4- 9: I N S T R U C T I O N

I T R AT I V E

D O. . . W H I L E

La boucle do...while dbute par l'excution du bloc d'instructions. Puis, l'expression est value:
tant qu'elle est vraie, le bloc d'instructions est rpt; lorsqu'elle devient fausse, le programme
quitte la boucle et passe aux instructions suivantes.
Il faut s'assurer que le bloc d'instructions modifie la valeur de l'expression si on veut viter d'tre
pris dans un boucle sans fin.

Le programme DOWHILE.C est une modification du programme TESTIF.C analys


prcdemment. Pour quitter la boucle do...while et terminer l'excution du programme, il suffit
de taper "0" en rponse la question pose. La Figure 4 -10 donne un exemple de
fonctionnement.
/* Programme:
* =========
*
* Auteur:
* Date:
* Rvision:
* Version:
*
* Volume:
* Fichier:
*
* Description:
*/

DOWHILE.C
=========
Robert Pesant
02/03/1990
09/04/1995
V3.1
COURS_13T
\CHAP.004\DOWHILE.C
Test de l'instruction "do ... while"

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
void main(void)
{
int b;
clrscr();
do

{
printf("Entrez une valeur pour la variable entire \"b\" (0 pour sortir): ");
scanf("%d", &b); fflush(stdin);

printf("La variable \"b\" est <= ");


if(b > 20)
{
gotoxy(21, wherey());
clreol();
printf("> que");
}
printf(" 20.\n\n");
}
while(b!=0);
}

printf("Fin!\a");

F I G U R E 4-1 0: E X C U T I O N

DE

DOW HI LE . E X E

Instruction itrative while


L'instruction itrative while se comporte comme la boucle do...while, la diffrence prs que
l'expression est value en dbut de boucle. Il y a donc possibilit que le bloc d'instructions ne
soit jamais excut, si le tout premier test donne un 0 logique ou un FAUX. La Figure illustre
bien cette diffrence.

Syntaxe de while

Ordinogramme de while
Dbut de
while

while(expr)
{
instr;
}

Note :
Le bloc d'instructions de
while peut ne jamais tre
excut, car le test de
s'effectue au dbut de la
boucle.

valuer
l'expression
expr
expr
expr

== VRAI ?

NON

Fin de
while

OUI

Excuter
l'instruction
instr
F I G U R E 4-11: I N S T R U C T I O N

I T R AT I V E

WHILE

Le programme WHILE.C est une copie modifie du programme TSTKBHIT.C du chapitre


prcdent. Tant que lusager nappuie pas sur une touche, while(!kbhit()), le compteur est
incrment de 1 chaque seconde. Puis, sa valeur est affiche pour servir de chronomtre. De
plus, lusager a trois secondes en dbut de programme pour quitter avant mme que le
chronomtre ne se soit mis en fonction. Cette option illustre le fait que le bloc dinstructions
dune boucle while peut ne jamais tre excut. Les saisies dcran durant les diffrentes phases
de lexcution sont prsentes la Figure 4 -12.
/* Programme:
* =========
*
* Auteur:
* Date:
* Rvision:
* Version:
*
* Volume:
* Fichier:
*
* Description:
*/
#include
#include
#include
#include

<stdio.h>
<conio.h>
<string.h>
<dos.h>

WHILE.C
=======
Robert Pesant
24/02/1996
24/02/1996
V1.0
COURS_13T
\CHAP.004\WHILE.C
Test de l'instruction "while"

void main(void)
{
int i = 0;
clrscr();
gotoxy((41 - strlen("CHRONOMETRE")/2),1);
printf("CHRONOMETRE");
gotoxy((41 - strlen("***********")/2),2);
printf("***********");
gotoxy((41 - strlen("Pour empcher le chrono de dbuter,")/2),4);
printf("Pour empcher le chrono de dbuter,");
gotoxy((41 - strlen("appuyez sur une touche maintenant! (Dlai max = 3 sec)")/2),5);
printf("appuyez sur une touche maintenant! (Dlai max = 3 sec)");
sleep(3);
gotoxy(1,4); clreol();
gotoxy(1,5); clreol();
gotoxy((41 - strlen("Pour quitter en tout temps, appuyez sur une touche.")/2),4);
printf("Pour quitter en tout temps, appuyez sur une touche.");
while(!kbhit())
{
gotoxy((41 - strlen("
secondes")/2),6);
printf("%3d secondes", i++);
sleep(1);
}
getch();

gotoxy(1,4); clreol();
gotoxy((41 - strlen("Une touche pour sortir au DOS.")/2),4);
printf("Une touche pour sortir au DOS.");
gotoxy((41 - strlen("Fin!")/2),8);
printf("Fin!\a");
getch();
clrscr();

F I G U R E 4- 12: E X C U T I ON

DE

W HI L E . E X E

Instruction itrative for


L'instruction itrative for constitue une boucle dont le nombre d'excutions est connu d'avance
puisque dtermin en gnral par un compteur. C'est ce qui la diffrencie des boucles while et
do...while qui attendent, en gnral, un vnement pour terminer leur excution. Sauf cas
particuliers, il est trs difficile de prdire le nombre de fois qu'elles seront rptes.
La Figure 4 -13 prsente la syntaxe gnrale ainsi que lordinogramme de fonctionnement de
l'instruction itrative for.

Syntaxe de for

Ordinogramme de for

for(expr_a; expr_b; expr_c)


{
instr;
}
Note :
En gnral,
expr_a
l'initialisation du compteur
de la boucle,
expr_b
test de la fin du compte et
expr_c
est l'incrmentation
du compteur.

Dbut de
for

valuer
l'expression
expr_a

est
est le

valuer
l'expression
expr_b

expr_b
VRAI ?

==

NON

Fin de
for

OUI

Excuter
l'instruction
instr

valuer
l'expression
expr_c
F I G U R E 4- 13: I N S T R U C T I ON

I T R ATI V E

FOR

La premire expression, expr_a, est value une seule fois, juste avant d'entrer dans le corps de la
boucle: elle sert initialiser le compteur de cette boucle.
Puis, expr_b est teste: si elle est vraie, le bloc d'instructions de for est excut; sinon, le
programme quitte cette boucle pour poursuivre son droulement.
Aprs l'excution du bloc d'instruction, expr_c est value: en gnral, on s'en sert pour
incrmenter le compteur. expr_b est teste nouveau pour savoir si la boucle doit tre rpte
ou si elle doit tre quitte dfinitivement.

Le programme TESTFOR.C utilise une boucle for dont le compteur est incrment de 32
jusqu' 63 inclusivement pour afficher les 32 premiers caractres imprimables de la table des
codes ASCII. Ces caractres sont spars par un espace, comme le montre la Figure 4 -14.
/* Programme:
* =========
*
* Auteur:
* Date:
* Rvision:
* Version:
*
* Volume:
* Fichier:
*
* Description:
*/

TESTFOR.C
=========
Robert Pesant
02/03/1990
24/02/1996
V1.4
COURS_13T
\CHAP.004\TESTFOR.C
Test de l'instruction "for"

#include <stdio.h>
#include <conio.h>
void main(void)
{
int i;
clrscr();
printf("Impression des codes ASCII (32 63)\n");
printf("====================================\n\n");
for(i = 32; i <= 63 ; i++)
{
putch(i); putch(' ');
}
}

printf("\n\nFin!\a");

F I G U R E 4- 14: E X C U T I ON

DE

TESTFOR.EXE