Subsections

• Qu'est qu'une instruction ?

3 Structures de contrôle

     

Très sommairement, un programme C est constiué de définitions et déclarartions de variables et de fonctions. Les fonctions sont construites à l'aide d'instructions combinées entre elles avec des structures de contrôles.

Qu'est qu'une instruction ?

Une expression telle que x=0, i++ ou printf("coucou\n") sont des instructions lorsqu'elles sont suivies du caractère point-virgule (';).

x=0;
i++;
printf("coucou\n");

Le point-virgule est appelé terminateur d'instruction.   Même si n'importe quelle expression peut être utilisée par écrire une instruction, les instructions intéressantes sont celles qui provoquent un effet de bord i.e. qui permettent, outre le fait d'évaluer cette expression, de modifier l'état d'un objet. C'est le cas de l'affectation qui modifie le contenu de l'opérante gauche!

Les instructions composées   ou blocs   sont construits avec des instructions simples regroupées à l'aide des accolades { et }. On peut déclarer des variables au début d'un bloc; nous en parlerons plus longuement dans le chapitre 4. L'accolade fermante n'est pas suivie d'un point-virgule.

{
int i;
i = 32;
printf("coucou\n");
}

3.1 L'instruction if

    Cette instruction conditionnelle permet d'exécuter des instructions de manière sélective en fonction du résultat d'un test. La syntaxe de l'intruction est :

 
if (expression) instruction1
if (expression) instruction1 else  instruction2
 

Si l'expression est vraie (valeur non nulle), l'instruction1 s'exécute; sinon, dans le deuxième cas, c'est l'instruction2 qui s'exécute.

Rappellons que si la valeur d'une expression est différente de 0, la valeur booléene de l'expression est vraie. il en découle que les deux écritures suivantes sont équivalentes :

 
if (expression) ...
 

et

 
if (expression != 0) ...
 

Toutesfois, on préferera la deuxième écriture pour des raisons de clarté.

D'après la syntaxe de l'instruction if, la partie else est facultative; il en découle une ambiguité lorsqu'il y a des instructions if imbriquées.

Dans l'exemple suivant, comme le suggère l'indentation du programme ,

 
if (expression1) 
    if (expression2) 
        instruction1
    else
        instruction2
 

l'instruction2 correspond au else de l'expression2.

L'écriture suivante est strictement identique à la première.

 
if (expression1) 
    if (expression2) 
        instruction1
else
    instruction2
 

Visiblement, le programmeur veut faire correspondre l'instruction2 au else de l'expression1. Comment faire ? Il suffit de transformer l'instruction imbriquée en un bloc d' instruction(s) de la manière suivante:

 
if (expression1) {
    if (expression2) 
        instruction1
} else 
    instruction2
 

Voici une construction, que l'on rencontre fréquemment, qui permet de faire une étude de cas:

 
if (expression1) 
    instruction1
else if (expression2) 
    instruction2
else if (expression3) 
    instruction3
else 
    instruction4
 

Cette instruction effectue successivement chacun des tests et aucun des tests n'est vraie, l'instruction4 sera exécutée (instruction par défault).

3.2 L'instruction switch

         

On dispose d'une instruction pour faire une étude de cas: c'est l'instruction switch.

 
switch (expression) {
    case constante_1 : instruction_1
    case constante_2 : instruction_2
    ...
    case constante_N : instruction_N
    default : instruction
}
 

Si la valeur de expression vaut constante_I, on exécute la suite des instructions commen¸cant à instruction_I. Attention, cette instruction ne se contente pas d'exécuter les instructions comprises entre instruction_I et instruction_I+1; elle exécute toutes les instructions instruction_I ainsi que toutes celles qui suivent instruction_I jusqu'à la rencontre de l'instruction break ou de la fin de l'instruction switch.

Lorsque la valeur de l'expression est égale à aucune des constantes mentionnées, ce sont les instructions etiquetées par default qui seront exécutées.

Exemple.

main() {
    char c;
    c = getchar();
    switch(c) {
        case '1' :
        case '2' :           /* notez l'absence d'instruction ici */
        case '3' :
        case '5' :
        case '7' : 
            printf("%c est un nombre premier\n", c);
            break;           /* notez l'instruction break */
        case '6' :
            printf("%c est un multiple de 3\n", c);
                             /* notez l'absence d'instruction break */
        case '4' :
        case '8' :
            printf("%c est un multiple de 2\n", c);
            break;
        case '9' :
            printf("%c est un multiple de 3\n", c);
            break;
        default :            /* instruction par défaut */
            printf("%c n'est pas un chiffre\n", c);
    }
}

Dans le programme ci-dessus, on a regroupé les cas 1, 2, 3, 5 et 7 pour n'écrire qu'une seule fois l'instruction d'affichage. L'instruction break arrête l'exécution de ce switch. Le chiffre 6 est à la fois un multiple de 2 et de 3. On factorise une partie de l'affichage avec les cas 4 et 8; d'où l'abscence de l'instruction break.

3.3 Les instructions while, do et for

Les instructions itératives ou boucles sont réalisées à l'aide d'une des trois structures de contrôle suivantes:      

 
while (expression) 
    instruction

do  
    instruction 
while (expression);

for (expression1; 
     expression2; 
     expression3) 
  instruction
 

L'instruction while

La structure de contrôle while évalue l'expression et exécute l'instruction tant que cette expression est vraie.

Le programme suivant affiche à l'écran (dans l'ordre) tous les nombres de 10 à 0.

 
main() {
    x = 10;
    while (x >= 0)  {      /* tant que x est positif */
        printf("%d", x);    /* imprimer x */
        x = x -1;           /* décrémenter x */
    }
}
 

Autre version de ce même programme

 
main() {
    x = 10;
    while (x >= 0)          /* tant que x est positif */
        printf("%d", x-);  /* imprimer et décrémenter x */
}
 

L'instruction do ... while

Une variante de cette instruction while est l'instruction do ... while. Contrairement à l'instruction while, l'instruction

do instruction while (expression);

est exécutée au moins une fois. L'itération s'arrête lorsque l'expression est fausse.

L'instruction for

L'instruction for, comme l'instruction while, n'exécute l'instruction que si l'expression est vraie.

 
for (expression1;                  /* Initialisation         */ 
        expression2;               /* Conditions d'arrêt     */
        expression3)               /* Fin du corps de boucle */
    instruction;
 

Cette instruction qui est composée de trois parties séparées par des point-virgules: expression1 constitue les initialisations nécessaires avant l'entrée dans la boucle. expression2 constitue les conditions de bouclage. expression3 constitue les instructions de fin de boucle. L'instruction for peut se traduire avec l'instruction while de la manière suivante:

Les parties expression1, expression2 et expression3 peuvent être éventuellement être vides. Par exemple, on effectue une boucle infinie avec l'instruction

 
for (; ; ) 
    instruction
 

L'opérateur virgule (,) est généralement utilisé pour combiner plusieurs initialisations et plusieurs instructions de fin du corps de boucle.

Exemple.

 
for (i=1, j=10; i < j; i++, j-) {
  ...
}
 

3.4 Les instructions goto, break, continue et return

L'instruction break

  L'instruction break que l'on a déjà vu lors de la description de l'instruction switch. En fait, l'instruction break est utilisée dans les structures de contrôle : switch, while, do ... while et for.

Dans une boucle, cette instruction provoque la sortie immédiate de la boucle sans tenir compte des conditions d'arrêt de la boucle.

L'utilisation de l'instruction break dans les boucles n'est que très rarement utilisée. Dans la quasi totalité des cas, une bonne condition d'arrêt sera utilisée pour sortir de la boucle.

L'instruction continue

 

Dans une structure de contrôle while, do ... while et for, l'instruction continue produit l'abandon de l'itération courante et, si le condition d'arrêt l'autorise, le démarage de l'itération suivante.

L'instruction return

 

L'instruction return ou return expression provoque l'abandon de la fonction en cours et le retour à la fonction appelante. Le résultat est la valeur que la fonction appelée renvoie à la fonction appelante. Comme dans le cas des passage d'arguments d'une fonction, la valeur retounée par la fonction subit les conversions habituelles (voir section 2.3 et chapitre 4). Lorque la fonction ne retourne aucune valeur (cas d'une procédure), on utilisera l'instruction return sans argument.

L'infâme instruction goto

  Une étiquette est un identificateur; elle sera suivie par un deux-point (:) et sera placée devant une instruction. L'instruction

 
    goto étiquette
 

tranfère le contrôle à l'instruction préfixée par l'étiquette mentionnée.

Une étiquette n'a pas besoin d'être déclarée (contrairement aux variables); de plus, elle est locale à une fonction i.e. qu'il ne peut y avoir un goto vers une étiquette figurant dans une autre fonction que celle dans laquelle se trouve l'instruction goto.

Dans la quasi totalité des programmes, l'instruction goto n'est pas utile. Elle n'est employée que dans certains programmes générés automatiquement par un autre programme.

Un utilisateur humain peut et doit toujours se passer de cette instruction.