Les instructions de contrôle :

Le langage C dispose des instructions qui permettent de réaliser des choix, des boucles, des branchements ou des choix multiples. 

Ces instructions peuvent éventuellement faire intervenir d’autres instructions contenues dans des blocs.

En langage C, un bloc est délimité par des accolades ( { et } ). Il peut contenir :

Plusieurs instructions : {instruction1 ; intruction2 ;….}

Une seule instruction : {instruction ;} ou { ;}

Aucune instruction ; ce sont des blocs vides :  { }

L'instruction IF:

L’instruction if vérifie si l’expression booléenne est VRAIE ou FAUSSE puis exécute une ou plusieurs instructions selon le résultat.

Si le résultat du test de l’expression est vrai alors le(s) instruction(s) sera(seront)  exécutée(s). S’il est faux, les lignes de code situées après le "FIN" de l’instruction " if " sont exécutées.

Syntaxe :

if (expression) 
     instruction;

Exemple :

{
     int x  = 5 ;
     if (x)
     {
         printf ("x = %d\n", x) ;
     }
     while (1){ } ; //peut aussi s'écrire while(1); sans accolades.
 }

Le programme précédent affiche  x = 5.

Qu’en sera-t-il si x = 0 ?.  Si x = 256? ou Si x = -xx

Le programme n’affichera rien, car l’expression évaluée par if est fausse.

L’instruction if - else :

L’instruction if .. else fonctionne comme l'instruction if. La seule différence est que, si le résultat du test de l'expression est vraie, l’intsruction1 sera exécutée ; sinon ce sera l’instruction2.

Syntaxe :

if (expression)
      intsruction1;
   else 
      instruction2;

Exemple: Afficher si un nombre est pair ou impair.

# include <stdio.h>
int main(void)
{
	     int number=23;
	     if(number%2)
          {
              printf("%d est nombre impair", number);
          }
      else
          {
              printf("%d est nombre pair", number);
          }
}

Résultat de l'affichage: 23 est un nombre impair.

L’instruction : if - else if

L’expression1 est d’abord évaluée par l’instruction if qui retournera un résultat vrai (TRUE) ou faux (FALSE). Si le résultat est vrai, l’instruction1 est exécutée, si le résultat est faux l’expression2 sera évaluée, par l’instruction else if. Si le résultat est vrai, l’instruction2 est exécutée ; si le résultat est faux, l’instruction3 est exécutée.

Syntaxe :

if (expression1)
          instruction1;
else if (expression2)
          instruction2;
else
          instruction3;

Exemple: sélection des canaux radio

if((freq>0.5)&&(freq<1.5))
     printf("Vous êtes sur la bande de fréquences 1\n");
else if((freq>2.5)&&(freq<4.5))
     printf("Vous êtes sur la bande de fréquences 2\n");
else if((freq>5)&&(freq<6.5))
     printf("Vous ête sur la bande de fréquences 3\n");
else
     printf("Bande de fréquences non disponible\n");

L'instruction switch:

Plusieurs instructions if imbriquées, peuvent être remplacées par un switch.  Cette instruction signifie en d'autres termes: selon les cas...faire.

Syntaxe :

switch(expression)
{
     case const_1 : instructions1 ;
                    break;
     .
     .
     .
     case const_n : instructions_n ;
                    break;
     default :  instructions_n+1 ;
}

L’expression  entre parenthèses après le mot switch est évaluée, puis vérifiée pour voir si elle est égale à Const_xx de chacune des clauses case, en commençant par const_1. Dans l’affirmative, les instructions de la clause case correspondante sont exécutées, puis se terminent par un "break;" qui demande de sortir du bloc "switch".

En l'absence de l'instruction "break;" toutes les autres clauses case qui suivent celle exécutée sur condition vrai, seront automatiquement exécutées.

La dernière instruction "default:" est exécutée lorsque, aucune valeur (Const_xx) précédente n'est satisfaisante.

Exemples:

Exemple1:

switch(letter)
     {
        case 'a': printf("Vous avez tapé la lettre 'a'\n");
                  break;
        case 'e': printf("Voua avez tapé la lettre 'c'\n");
                  break;
        case 'o': printf("Vous avez tapé la lettre 'o'\);
                  break;
        case 'u': printf("Vous avez tapé la lettre 'u'\n");
                  break;
        default:  printf("Aucune lettre ne correspond\n");
     }

Exemple 2

shitch(channels)
{
   case 4...7:
             printf ("Stations VHF\n");
				 break;
   case 9...12:
             printf ("Stations VHF\n");
				 break;
   case 3: case 8: case 13:
             printf ("Aucune station\n");
				 break;
   case 14...69:
             printf ("Stations UHF\n");
				 break;
   default:
             printf ("Signaux d'intensité faible\n");
}

Cet exemple montre que les instructions peuvent être séparées de la clause case par un passage à la ligne.

Dans l'instruction de la ligne 3, la vérification se fera dans les cas 4, 5, 6, 7. A la ligne 9, la vérification se fera dans les cas 3, 8 et 13.

Les boucles :

Boucle FOR :

La boucle for est une structure de répétition, afin d’exécuter un nombre de fois une série d'instructions.

La boucle for comporte trois expressions:

• l'expression 1: elle est évaluée une seule fois avant d'entrer dans la boucle. 
• l'expression 2: elle conditionne la poursuite de la boucle. Elle est évaluée avant chaque parcours.
• l'expression 3: elle est évaluée à la fin de chaque itération pour modifier la variable de boucle.

Par exemple si i est la variable de boucle:  l'expression 1 sera i = 0, l'expression 2 sera i < 10, et l'expression 3 sera i++.

Syntaxe :

for(expression1 ;  expression2 ;  expression3)
                    { instructions; }

Dans une boucle for les accolades ne sont pas obligatoires pour une seule instruction.

Exemple :

# include <stdio.h>

int main(void)
 {
    int i ;
    for(i = 0 ; i < 5 ; i++)
     {
        printf("iteration n° %d\n", i) ;
     }
 }

Ce programme aura pour résultat :

iteration n° 0

iteration n° 1

iteration n° 2

iteration n° 3

iteration n° 4

La boucle WHILE :

C’est une boucle qui va s’exécuter tant que la condition donnée par l'Expression est vraie.

Syntaxe :

while(expression)

       { instructions; }

Si l’expression est vraie, les instructions seront exécutées et l’expression sera évaluée pour déterminer s'il faut de nouveau exécuter les instructions ou pas.

Il peut arriver que les instructions ne soient jamais exécutées ; c’est la cas lorsque la condition de l’expression est toujours fausse.

Exemple:

# include <stdio.h>

int main(void)
{
   int i ;
   while(i < 5)
      {
         printf ("interation n°%d\n", i) ;
      }
 }

Ce programme produit le même résultat que l'exemple vu avec la boucle for.

Il est possible de créer une boucle infinie avec la boucle while. Par exemple:

while(1)
  {
	 
   }

La boucle DO WHILE :

A l'inverse des boucles for et while qui testent la condition au début de boucle, la boucle do while teste la condition en fin de boucle. Cela garantit l’exécution des instructions à l’intérieur de celle-ci au moins une fois.

Syntaxe :

do
     { instructions;
       } while (expression);

Les instructions sont exécutées, puis l’expression est ensuite évaluée.

Exemple:

# include <stdio.h>

int main (void)
{
  int i ;
  do
    {
       printf("interation n°%d\n", i);
    } while (i < 5) ;
}

Le résultat produit par ce programme est le même que celui des exemples des boucles for et while.