Chapitre suivantIndex des CoursChapitre précedentChapitre 5

LES INSTRUCTIONS DE CONTROLE

 

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’étiquettedefault

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

}

II.2 Syntaxe de l’ instruction switch

    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- L’INSTRUCTION WHILE

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

V.1 Exemple d’introduction de I’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.

VI.2 L’instruction continue

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

}

Chapitre précedentIndex des CoursChapitre suivant

Révisé le :23-Sep-2007| ©2007 www.technologuepro.com