Objectifs
• Connaître les différentes instructions de contrôle du langage C.
• Connaître la syntaxe de chacune de ces instructions.
Eléments de Contenu
• L’instruction if
• L’instruction switch
• L’ Instruction do … while
• L’instruction while
• L’instruction for
• Les instructions de branchement inconditionnel : break, continue et goto.
A priori, dans un programme, les instructions sont exécutées séquentiellement, c’est à dire dans
L’ordre où elles apparaissent. Or, la puissance et le “comportement intelligent” d’un programme
Proviennent essentiellement :
• de la possibilité d’effectuer des “choix’, de se comporter différemment suivant les “circonstances” (celles-ci pouvant être, par exemple, une réponse de l’utilisateur, un résultat de calcul, …).
• de la possibilité d’effectuer des “boucles”, c’est à dire de répéter plusieurs fois un ensemble donné d’instructions.
Tous les langages disposent d’instructions, nommées “ instructions de contrôle’’, permettant de réaliser Ces choix ou ces boucles. Suivant le cas, celles-ci peuvent être :
• basées essentiellement sur la notion de branchement (conditionnel ou inconditionnel); c’est, par exemple, le cas du langage Basic,
• ou, au contraire, traduire fidèlement les structures fondamentale de la programmation structurée; c’est, par exemple, le cas du langage Pascal bien qu’eu toute rigueur, ce dernier dispose d’une instruction de branchement inconditionnel GOTO.
Le langage C est assez proche du pascal sur ce point puisqu’il dispose “d’instructions structurées” permettent de réaliser :
• des choix : instructions if... elseet switch
• des boucles : instructions : do…while, while et for
Toutefois, la notion du branchement n’est pas totalement absente du langage C puisque, il dispose (l’instructions de branchement inconditionnel :goto, break et continue,
Ce sont ces différentes instructions de contrôle du langage C que nous nous proposons d’étudier dans ce chapitre.
I-L’INSTRUCTION IF
I.1 Exemples d’introduction de l’instruction if
Soit l’exemple suivant :
if(a<=b)
printf(”croissant”);
e/se
printf(”décroissant’);
Ces quelques lignes constituent une instruction if Elles s’interprètent ainsi :si la condition a <= b est vraie (c’est à dire non nulle), on exécute l’instruction :
printf(”croissant”);
dans le cas contraire, on exécute l’instruction suivant le mot eIse :
printf(’décroissant ”);
Dans ce premier exemple, chacune des deux parties du choix se limite à une seule instruction simple. Il est possible d’en placer plusieurs en les regroupant en ce que l’on nomme un “bloc”. En voici un exemple :
if(a<=b)
{
Printf(”croissant ’);
max.=b ;
}
e/se
{
printf(”décroissant”);
max =a;
}
Le bloc joue un rôle important un en C et il peu être employé ailleurs que dans une instruction if .Etudions cette notion on détail.
1.2 Les blocs d’instructions
Il s’agit d’une suite d’instructions placées entre { et } . Les instructions figurant dans un bloc sont absolument quelconques. IL peut s’agir aussi bien d’instructions simples (terminés par un point—virgule) que d’instructions structurées (choix, boucles) lesquelles peuvent à leur tour renfermer d’autre blocs...
Vous voyez qu’il y a on C une sorte de récursivité de la notion d’instruction. D’une manière générale, dans la description de la syntaxe des différentes instructions, nous seront souvent amenés à mentionner ce terme d’instruction, celui désignera toujours n’importe quelle instruction C simple, structuré ou un bloc.
Un bloc peut se réduire à une seule instruction, voire même être vide. Voici deux exemples de bloc corrects :
{}
{ i=1 ; }
Le second bloc ne présente aucun intérêt en pratique puisqu’il pourra toujours être remplacé par ‘instruction simple qu’il contient.
1.3 Syntaxe de l‘instruction if
Le mot else et l’instruction qu’il introduit sont facultatifs, de sorte que cette instruction if présente deux formes.
if (expression) if (expression)
instruction 1 instruction 1
else
instruction 2
avec,:
• expression :expression quelconque.
• instruction I et instruction2 instructions quelconques, c’est à dire
- simple,
- bloc,
- instruction structurée.
Remarque :
La syntaxe de cette instruction n’impose en soi aucun point-virgule, s’ ce n’est ceux qui terminent naturellement les instructions simples qui y figurent.
1.4Quelques exemples
l’expression conditionnant le choix est quelconque. La richesse de la notion d’expression en C fait que celle-ci peut elle-même réaliser certaines actions. Ainsi :
if(++i <limite) printf(”ok’’);
est équivalent à
i=i+1
if (i< limite) printf(”ok’’);
de même:
if((c= getchar())!=’\n’)…
peut remplacer
c= getchar() ;
if(c !=’\n’)…
Par contre, if faut noter que:
if((+ +i< limite)&& ((c =getchar())!=’\n’))…
n’est pas équivalent à :
++i ;
c = getchar()
if((I<limite) && (c!= ‘\n’))
car, comme nous l’avons déjà dit, l’opérateur && n’évalue le second opérande que lorsque cela est nécessaire. Autrement dit, dans la première formulation, l’expression :
c= getchar()
n’est pas évaluée lorsque la condition + +i<limite est fausse ; elle l’est par contre dans a deuxième formulation.
1.5 Le cas des instructions if imbriquées
Nous avons déjà mentionné que les instructions figurant dans chaque partie du choix d’une instruction if pouvaient être absolument quelconques. En particulier, elles peuvent à leur tour renfermer des instructions if .Or, compte tenu de ce que cette instruction peut comporter ou ne pas comporter de ‘’else” il existe certaines situations où une ambiguïté apparaît. C’est le cas dans cet exemple :
if(‘a<=b) if(b<=c) printf (‘‘ordonné”);
else printf (‘‘non ordonné ‘‘) ;
Est-il interprété comme le suggère cette présentation
if(a<=b) if(b<=c) printf (‘‘ordonné”);
else printf(“non ordonné”);
Ou bien comme le suggère celle-ci :
if(a<=b) if(b<=c) printf (‘‘ordonné”);
else printf(“non ordonné”);
La première interprétation conduirait â afficher « non ordonné lorsque la condition a<=b est fausse, tandis que la seconde n’afficherait rien dans ce cas la. La règle adoptée par le langage C pour lever une telle ambiguïté est la suivante :
Un else se rapporte toujours au dernier if rencontré auquel un else n’est pas encore attribué.
Ainsi, dans notre cas c’est la deuxième représentation qui suggère le mieux ce qui se passe.
II - L’INSTRUCTION SWITCH
11.1 Exemples d’introduction à l’instruction switch
a) premier exemple
Voyons ce premier exemple de programme accompagné de trois exemples d’exécution.
main ()
{
int n ; Donner un entier : 0
printf ( “donnez un entier entier : “); nul
scanf(”%d”, &n); au revoir
switch( n)
{ Donner un entier :1
case O : printf (“nul\n“); un
break; au revoir
case 1: printf (“un\n“);
break;
case 2 : printf (“deux\n”); Donner un entier : 2
break; deux
} au revoir
printf(“au revoir\n”);
}
L’instruction switch s’étend ici sur 9 lignes (elle commence au mot switch). Son exécution se déroule comme suit : On commence tout d’abord par évaluer expression figurant après le mot switch (ici n). En suite en recherche dans le bloc qui suit s’il existe une étiquette de ta forme “case x” correspondant à la valeur ainsi obtenue. Si c’est e cas, on “se branche” à l’instruction figurant après cette étiquette. Dans le cas contraire on passe à instruction qui suit le bloc.
ainsi, par exemple quand n vaut 0, on trouve effectivement une étiquette “case 0” et l’on exécute Instruction correspondante, c’est à dire :
pintf (“nul\n“) ;\
On passe ensuite, naturellement, à l’instruction suivante, à savoir ici :
break;
Celle-ci demande en fait de sortir du bloc. Le rôle de cette instruction est fondamental. Voyez, à titre d’exemple, ce que produirait ce même programme en l’absence de break.
main()
{
int n ; Donner un entier : 0
printf(“donnez un entier : “) ; nul
scanf(“%d,&n) ; un
switch(n) deux
{ au revoir
case 0 :printf(“nul\n“); Donner un entier :2
case1:printf(“un\n“) ; deux
case2:printf(“deux\n“) ; au revoir
}
printf(“au revoir\n“) ;
}
b) l’étiquette“ default“
Il est possible d’utiliser le mot-clé “default” comme étiquette à laquelle je programme se “branchera“ dans le cas où aucune valeur satisfaisante n’aura été rencontrée. En voici un
Exemple :
main()
{
int n ; donnez un entier :
printf(“donnez un entier : “) ; deux
scanf(“%d“ ;&n) ; au revoir
switch (n)
{
case 0 :printf(“nul\n“); donner un entier:25
break; grand
case 1 :printf(“un\n“); au revoir
break ;
case 2 :printf(“deux\n“);
break ;
default :printf(“grand \n“);
}
printf(“au revoir \n“);
}
Switch(expression)
{
case constante 1 :[ suite_d’instruction_1]
case constante 2 : [ suite d’instruction_ 2]
case constante_ n :[ suite d’instruction_n]
default :[ suite_d’instruction]
}
Avec:
Constante : expression constante entière (mais char est accepté car il sera converti en int). Suite _d’instruction : séquence d’instructions quelconques.
N.B. : les crochets ([et]) signifient que ce qu’ils renferment est facultatif.
IIl- L’INSTRUCTION DO …WHILE
III.1 Exemple d’introduction de l’instruction do ... while
main()
{
int n ;
do donner un nombre positif: -5
{ vous avez fourni -5
printf (“donner un nombre positif : ‘‘) ; donner un nombre positif: - I
scanf (‘‘%d’’, &n ) ; vous avez fourni –1
donner un nombre positif: 3
vous avez fourni 3
}
réponse correcte
while (n<=0) ;
printf (“réponse correcte‘‘) ;
}
l’instruction
do{…} while (n<=0)
répète l’instruction qu’elle ”contient” (ici un bloc) tant que la condition mentionnée (n<=0) est vraie (c’est à dire en C non nulle). Autrement dit, dans l’exemple ci-dessus, elle demande un nombre à l ‘utilisateur tant qu’il ne fournit pas une valeur positive.
On ne sait pas à priori combien de fois cette boucle sera répétée. Toutefois elle est toujours parcourue au moins une fois. En effet la condition qui régit cette boucle n’est examinée qu’à. La fin de chaque répétition (puisque la partie while figure en fin).
Il faut noter que la sortie de la boucle ne se fait qu’après un parcours complet de ses instructions et non dès que la condition mentionnée devient fausse. Ainsi, dans l’exemple ci-dessus, même après que .l‘utilisateur ait fourni une réponse convenable, il y a exécution de
L‘instruction d’affichage:
printf (”vous avez fourni %d \n”,n) ;
111.2 Syntaxe de l’instruction do …while
do instruction
while (expression,);
Commentaires :
• Notez bien la présence de parenthèses autour de l’expression qui régit la poursuite de la boucle et d’un point-virgule àla fin de cette instruction.
• Lorsque l’ instruction à répéter se limite à une seule instruction simple, n’omettez pas le point- virgule qui la termine. Ainsi:
do c = getchar() while (c != ‘x’);
est incorrecte. Il faut écrire :
do c= getchar() ;while(c!=‘x’);
• N’oubliez pas que l’expression suivant le mot while peut être aussi élaborée que vous le souhaitez et qu’elle permet ainsi de réaliser certaines actions.
• L’instruction à répéter peut être vide. toutefois, elle doit être terminée par un point-virgule. Ainsi ces expressions sont correctes :
do; while(... )
do {} while (... )
• L’instruction :
do{} while (1)
représente une boucle infinie ; elle est syntaxique ment correcte, bien quelle ne présente en pratique aucun intérêt.
IV. 1 Exemple d’introduction de l’instruction while
main()
{
int n,som ;
som=0
while(som<100)
{
printf (”donne un nombre :“); donner un nombre : 30
scanf (“%d”, &n); donner un nombre : 50
som + = n; donner un nombre :35
} somme obtenue : 115
printf(”somme obtenue : %d”,som,) ;
}
L’instruction
while (som<100)
répète l’instruction. qui suit (ici un bloc) tant que la condition mentionnée est. vraie (non nulle), comme le ferait do... while Par contre, cette fois la condition de poursuite est examinée avant chaque parcours de la boucle et non après. Ainsi une telle boucle peut très bien n’être parcourue aucune fois si la condition est fausse dés le départ.
IV.2 Syntaxe de l’instruction while
While (expression)
Instruction
Commentaires :
• Notez bien la présence de parenthèses autour de l’expression qui régit la poursuite dela boucle.
• L’expression utilisée comme condition de poursuite est évaluée avant le premier tour. Il est donc nécessaire que sa valeur soit définie à. ce moment.
• La construction
while(expression1 , expression2) ;
est équivalente à :
do expression 1
while (expression 2)
V- L’INSTRUCTION FOR
main; ()
{
int i; bonjour I fois
for (i=1 ; i <= 5; I++) bonjour 2fois
{ bonjour 3fois
printf (“bonjour”); bonjour 4fois
printf (‘’%dfois\n’’ ,i) ; bonjour 5fois
}
{
La ligne
for (i=I;i <=5; i++)
Comporte trois expressions. La première est évaluée (une seule fois) avant d’entrer dans la boucle. La seconde conditionne la poursuite de la boucle elle est évaluée avant chaque parcours .la troisième, enfin, est évaluée à la fin de chaque parcours.
Le programme précédent est en fait équivalent au suivant :
Main()
{
int I;
while(I<=5)
{
printf(“bonjour”);
printf(“%d fois\n”,i) ;
i++;
}
}
V.2 Syntaxe de l’instruction for
For([expression 1];[expression 2];[expression 3])
instruction
Commentaires :
· D’une manière générale, nous pouvons dire que :
for ([expression1] ;[ expression2 ]; [expression3]) instruction
est équivalent à :
expression1 ;
while (expression2)
{
instruction
expression3
}
Chacune des trois expressions est facultative (pas obligatoire). Ainsi, ces instruction sont équivalentes à l’instruction for de notre premier exemple de programme :
i=1 ;
for (; i <= 5, i++)
{
printf ( “bonjour’’) ;
printf(‘’%d fois\n’’,i);
}
i=I;
for (; i <= 5;)
{
printf (“bonjour’’);
printf(‘’%d fois\n’’,i);
i++;
}
Notez que lorsque expression 2 est absente elle est considérée comme vraie.
· La richesse de a notion d’expression on C permet de regrouper plusieurs actions dans une expression. Ainsi :
for (i=0,j=1,k=5;...;…)
est équivalent à :
j=1;
k = 5;
for (i =0;…;…)
· Les constructions :
for ( ; ; );
for ( ; ; ) {}
Sont syntaxiquement correctes. Elles représentent des boucles infinies de corps vide.
VI- LES INSTRUCTION DE BRANCHEMENT INCONDITIONNEL: BREAK, CONTINUE ET GOTO
Ces trois instructions fournissent des possibilités diverses de branchement inconditionnel. Les deux premières s’emploient principalement au sein de boucles tandis que la dernière est d’un usage libre mais peu répandu, à partir du moment où on cherche à structurer ses programmes.
VI.1 L’instruction break
Nous avons déjà vu le rôle de break au sein du bloc l’une instruction switch.
Le langage C autorise également l’emploi de cette instruction dans une boucles. Dans ce cas, elle sert à interrompre le déroulement de la boucle, en passant à l‘instruction qui suit cette boucle. Bien entendu, cette instruction n’a d’intérêt que si son exécution est conditionnée par un choix.
Voici un exemple montrant le fonctionnement de break.
main()
{
int i début de tout /
for (i=1 ;i<=10 ;i++) bonjour
{ fin de tour 1
printf (‘’début de tour %d\n “i) ; début de tour 2
printf (“bonjour\n”); bonjour
if(i == 3) break ; fin de tour 2
printf(‘’fin de tour %d\n’’, i); début de tour 3
} bonjour
printf (“après la boucle\n’’); après la boucle
}
Remarque
En cas de boucles “imbriquées ’’, break fait sortir de la boucle la plus interne. De même, si break apparaît dans un switch imbriqué dans une boucle, elle ne fait sortir que du switch.
L’instruction continue permet de passer “prématurément” au tour de la boucle suivant En voici un premier exemple avec for :
Main()
{
int i ; début de tour 1
for (i=1 ;i <= 5; i++) début de tour 2
{ début de tour 3
printf (“début de tour %d\n “, i) ; début de tour 4
if(i<4) continue ; bonjour
début de tour 5
bonjour
}
}
et voici un second exemple avec do …while :
main ()
{
int n ; donnez un nombre > 0 :4
do son carré est: 16
{
printf (”donner un nombre >0”)
scanf (”%d”,n&n) ; donner un nombre supérieur à 0 :-5
if(n<0) svp>0 {
donner un nombre >0 :2
son carre est : 4
donner un nombre>0 :0
printf (” svp >0\n”), son carré est : O
continue
}
printf (“son carré est : %d\n “, n*n) ;
}
while(n) ;
}
Remarques :
Notez bien que lorsqu’elle est utilisée dans une boucle for, cette instruction continue effectue bien un branchement sur l’évaluation de l’expression de fin de parcours de boucle (nommée expression2 dans la présentation de Sa syntaxe) et non après.
En cas de boucles imbriquées, l’instruction continue ne concerne que la boucle la plus interne.
VI.3 L’instruction goto
Elle permet le branchement en un point quelconque. Et, voici Un exemple
Main()
{
int i ; début de tour 1
for (i=1 ;<=10 ;i++) bonjour
{ fin de tour 1
printf (“début de tour %d\n “,i) ; début de tour 2
printf(“bonjour\n“) ; bonjour
if(i= =3)goto sortie ; fin de tour 2
printf(“fin de tour %d\n“,i) début“ de tour 3
sortie printf (‘après la boucle\n“) ; après la boucle
}
Révisé le :23-Sep-2007| ©2007 www.technologuepro.com