Les contrôles des blocs d'instructions

1. Qu’est-ce qu’un bloc d’instructions ?

#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{  //------------------------- ouv bloc main B1 
int x,pasx;    // déclarations de variables locales au bloc main 
               // elles sont visibles (accessibles) dans ce bloc 
               // et tous les sous-blocs 
 
   {  //----------ouv B2 
      int c; 
      x=0; 
      c=rand()%256; 
      pasx=rand()%5; 
   }  // ---------ferm B2 
   x=640; 
 
   {  // ---------ouv B3 
      //c=10; // provoque erreur, c non visible dans ce bloc 
      x/=2; 
      pasx=15; 
 
   }  // ---------ferm B3 
   x+=pasx; 
   printf("x vaut : %d\n",x);  // affichage ? 
 
   Return 0; 
 
}  //-------------------------ferm bloc main
 

1. L’instruction if

SI et seulement si l’expression est vraie ALORS le bloc des instructions associées au if est exécuté. Il ne peut y avoir qu’un seul bloc associé au if.

if ( expression1 vraie){ 
    bloc instructions; 
}
 

Par exemple, soit une variable a, dans un programme on peut écrire :

if ( a >=100 ){    // test 
    printf( "a est supérieur ou égal à 100 \n"); // instruction 
}
 

Derrière un if il ne peut y avoir qu’un seul bloc c’est-à-dire une seule instruction. S’il y a plusieurs instructions il faut ouvrir et fermer le bloc mais s’il n’y en a qu’une, c’est inutile. L’exemple précédent peut s’écrire sans erreur à la compilation :

if ( a >=100 ) 
    printf( "a est supérieur ou égal à 100 \n");
 

Attention à l’indentation, c’est inutile pour la machine, en revanche c’est absolument nécessaire professionnellement pour rendre son code lisible.

Dans le cas d’une succession de if, chacun fait l’objet d’une évaluation :

if ( expression1 vraie){ 
    bloc instructions 1; 
} 
if ( expression2 vraie){ 
    bloc instructions 2; 
} 
if ( expression3 vraie){ 
    bloc instructions 3; 
}
 

Seuls les blocs dont la condition est vraie seront effectués : aucun, quelques-uns ou tous.

Des if peuvent être imbriqués, dans ce cas ils ne seront peut-être pas tous effectués, la série s’arrêtera au premier test faux rencontré :

if ( expression1 vraie){ 
    bloc instructions 1; 
    if ( expression2 vraie){ 
        bloc instructions 2; 
        if ( expression3 vraie){ 
           bloc instructions 3; 
        } 
    } 
}
 

Si (et seulement si) expression1 est vraie, alors les instructions 1 du bloc sont exécutées et expression2 est évaluée.

Si (et seulement si) expression2 est vraie, alors les instructions 2 du bloc sont exécutées et expression3 est évaluée.

Si (et seulement si) expression3 est vraie, alors les instructions 3 du bloc sont exécutées.

2. Le couple d’instructions if-else

SI l’expression est vraie, le bloc des instructions associées...

1. Branchement sélectif : switch, case et break

Une suite de if, else if, else comme :

if (i==0){ 
   instructions0; 
} 
else if (i==1){ 
   instructions1; 
} 
else if (i==7){ 
   instructions7; 
} 
else if (i==55){ 
   instructions55; 
} 
else{ 
   instructions_n; 
}
 

peut être remplacée par un switch qui est un aiguillage. Il fonctionne de la façon suivante :

switch(valeur_expression){ 
 
    case expression_constante_1 : 
          instructions1; 
          break; 
 
   case expression_constante_2 : 
          instructions2; 
          break; 
 
   case expression_constante_3 : 
          instructions3; 
          break; 
 
   default : 
          instructions_n; 
          break; 
}
 

Le bloc des instructions à exécuter est décidé à partir de la valeur de l’expression en paramètre du switch :

Il n’y a pas de limite au nombre de cas possibles. Mais chaque cas est identifié par une valeur constante, c’est-à-dire non variable après le mot-clé case.

L’instruction break provoque une sortie du bloc du switch. Sans le break, toutes les instructions des cas qui suivent le cas d’entrée sont exécutées.

Notre suite de if, if else peut s’écrire :

switch( i ){ 
 
    case 0 : 
           instructions0; 
           break; 
    case 7 : 
           instructions7; 
           break; 
    case 55 : 
           instructions55; 
           break; 
    default : 
           instructions_n; 
}
 

Selon la valeur de la variable i les instructions du cas correspondant sont exécutées jusqu’au break. Si i ne correspond à aucun des cas, alors c’est le cas par défaut qui est exécuté et s’il n’y a pas de cas par défaut, aucune instruction n’est exécutée....

1. Conjonction ET : opérateur &&

l'expression  E1 && E2 : 
    est vraie (vaut 1) si E1 ET E2 sont vraies 
    est fausse sinon (vaut 0)
 

int a = rand()%300; 
    if (a >= 100 && a<=200) 
           printf("a compris entre 100 et 200\n");
 

#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
int papier, declarer; 
 
    printf("Vous avez vos papiers ? (o/n)\n"); 
    scanf("%c",&papier); 
    // lorsqu'il y a plusieurs appels successifs de scanf() il est 
    // nécessaire de réinitialiser le buffer d'entrée (stdin) avec 
    // la fonction rewind() 
    rewind(stdin); 
 
    printf("Quelque chose a declarer ? (o/n)\n"); 
    scanf("%c",&declarer); 
 
    if( papier=='o' && declarer=='n') 
        printf ("C'est bon, vous pouvez passer\n"); 
    else 
        printf("Attendez la s'il vous plait\n"); 
 
    return 0; 
}
 

E1 && E2 && E3 && E4  est vraie si TOUTES sont vraies, faux sinon
 

if (x>0 && x<1024 && y>0 && y<768) 
     printf("(x,y) dans ecran en 1024-768\n");
 

#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
char farine, sel, oeufs, lait, gruyere; 
 
    printf("Dans le frigo y a-t-il des oeufs (o/n), du lait (o/n)" 
          "du gruyere (o/n)\n ?"); 
    scanf("%c%c%c",&oeufs, &lait, &gruyere); 
    rewind(stdin); 
 
    printf("Dans le placard y a-t-il de la farine (o/N)" 
        "et du sel (o/n) ?\n"); 
    scanf("%c%c",&farine...

1. Boucle TANT QUE : le while

La boucle while a la forme suivante :

while (expression vraie){ 
    instructions; 
}
 

Tant que la valeur de l’expression est vraie, c’est-à-dire non nulle et différente de 0, les instructions du bloc lié à la boucle sont répétées. Pour que la boucle puisse s’arrêter, il faut que l’expression devienne fausse et pour ce faire une des composantes du test doit être modifiée dans le bloc des instructions. Par exemple :

int a=3,i=0; 
    while (i<a){ 
        i++; 
        printf("i vaut %d\n",i); 
    } 
    printf("Fin de la boucle avec i=%d \n",i);
 

Tant que i est inférieur à a, les instructions sont exécutées :

au départ a vaut 3 et i vaut 0 : 
 
i < a : le test est vrai, les instructions sont effectuées, i est 
augmenté de 1 et i vaut 1. 
 
i < a : le test est vrai, les instructions sont effectuées, i est 
augmenté de 1 et i vaut 2. 
 
i < a : le test est vrai, les instructions sont effectuées, i est 
augmenté de 1 et i vaut 3. 
 
i < a : le test est faux, fin de la boucle, poursuite de l'exécution 
avec les instructions qui suivent le bloc de la boucle.
 

Le test peut être faux dès le départ et dans ce cas les instructions du bloc de la boucle ne sont pas exécutées, par exemple  :

#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
    int a; 
    printf("entrer une valeur entre 50 et 100\n"); 
    scanf("%d",&a); 
    while( a < 50 ||  a>100 ){ 
       printf("le nombre doit etre compris entre 50 et 100\n"); 
       scanf("%d",&a); 
       rewind(stdin); 
    } 
    printf("valeur entree : %d\n",a); 
    return 0; 
}
 

Si l’utilisateur entre au départ une valeur entre 50 et 100 le test de la boucle est faux et il n’y a pas de boucle. Il y a boucle tant que la valeur entrée par l’utilisateur est inférieure à 50 ou supérieure à 100.

2. Boucle FAIRE {...} TANT QUE : le do-while

La boucle do-while a la forme suivante :

do { 
    instructions; 
} while (expression) ;      // à noter...

1. Créer un menu utilisateur

Un programme qui se termine du fait d’une action de l’utilisateur repose toujours sur une boucle, c’est la base de sa dynamique. Pour créer un menu, le principe est de donner un choix de commandes à l’utilisateur via une interface et de mettre fin à la boucle si l’utilisateur le demande avec une commande spécifique. L’interface simple que nous proposons offre à l’utilisateur quatre choix :

printf ( "1 : Affiche bonjour\n" 
         "2 : Affiche il fait beau\n" 
         "3 : Entrer un nombre entier\n" 
         "0 : Quitter\n");
 

Ensuite le programme capture le choix de l’utilisateur et applique les traitements correspondants. Si l’utilisateur entre d’autres nombres que 0, 1, 2 ou 3, le programme signale qu’ils ne correspondent pas à des commandes :

#include <stdio.h> 
#include <stdlib.h> 
 
int main() 
{ 
int choix, res; 
    do{                                              // 1  
                                                      
       printf ( "1 : Affiche bonjour\n"              // 2 
                "2 : Affiche il fait beau\n" 
                "3 : Entrer un nombre entier\n" 
                "0 : Quitter\n"); 
 
       scanf("%d",&choix);                           // 3 
       rewind(stdin); 
 
       switch(choix){                                // 4 
        case 0 :  
           break; 
        case 1 : 
           printf("bonjour\n"); 
           break; 
 
        case 2 : 
           printf("il fait beau\n"); 
           break; 
 
        case 3 : 
           scanf("%d",&res); 
           rewind(stdin); 
           printf("le nombre est :  %d\n",res); 
           break; 
 
        default : 
           printf("Pas de commande %d\n",choix); 
           break; 
      } 
 
    }while(choix !=0);                               // 5 
 
    return 0; 
}
 

(1) (5) Instruction de boucle do-while. La boucle a lieu tant que la variable choix est différente de 0, elle se termine si la variable choix est égale à 0.

(2) Affichage du menu utilisateur.

(3) Première instruction exécutée au moins une fois, l’utilisateur entre une valeur pour la variable choix. L’appel de la fonction scanf() est suivi d’un appel à la fonction rewind() afin de réinitialiser le buffer des entrées clavier stdin et d’éviter une boucle infinie en cas d’erreur.

(4) À...

1. Qu’est-ce qu’une fonction ?

Une fonction prend la forme suivante :

<type du retour > <nom fonction> < ( liste de paramètres ) > 
 
{  ouverture bloc 
 
   (...)    // les instructions du bloc 
 
   return  (...)  //instruction de retour si sortie de valeur 
 
}  fermeture bloc
 

La première ligne constitue ce que l’on nomme "l’en-tête de la fonction". Le bloc d’instructions constitue le corps de la fonction.

L’en-tête comprend le type de la valeur de retour, le nom de la fonction et une liste de paramètres entre parenthèses. Les paramètres sont simplement des variables locales à la fonction qui ont la particularité de pouvoir recevoir des valeurs au moment de l’appel de la fonction. S’il n’y a pas de paramètre, la liste est vide ce qui est précisé avec le mot-clé void. La valeur de retour n’est pas obligatoire non plus. S’il n’y a pas de valeur de retour, le type du retour est void. Une fonction qui ne retourne pas de valeur...

1. Visibilité des variables

La visibilité et la durée de vie d’une variable est relative au lieu de sa déclaration dans le programme. Le niveau d’imbrication de bloc est appelé la profondeur de sa déclaration.

#include<stdlib.h>            // niveau 0 en global, hors bloc 
int x=0; 
void test(int a); 
 
int main() 
{                             // bloc niveau 1 
int i=0; 
      {                       // bloc niveau 2 
      int  y=9; 
          {                   // bloc niveau 3 
          int w=rand(); 
              test(w); 
          } 
      } 
      test(i); 
} 
 
void test(int a) 
{                             // autre bloc niveau 1 
int b; 
            ...// instructions de la fonction 
}
 

1. Pourquoi soigner le style ?

Le but du style de la programmation est de s’assurer que le code sera facile à lire et partageable au sein d’une équipe. Un bon style est indispensable à toute bonne programmation.

Un programme sans rigueur est peu lisible, peu fiable, difficile à corriger et à comprendre. Il devient vite impossible à développer et se trouve finalement figé dans son incompréhensibilité. Plus un programme est rendu incompréhensible par l’absence de rigueur de sa présentation moins il est possible de continuer son développement, d’apporter des modifications ou des nouvelles fonctionnalités, voire tout simplement de le déboguer. Le style est finalement en relation avec l’efficacité de la conception. Aujourd’hui le style s’est normalisé et il est associé à des conseils et des recommandations qui varient très peu d’une communauté de développement à une autre. Le style n’est pas secondaire, c’est une question de discipline, de rigueur et d’efficacité dans le travail. Montrez votre code et rien qu’à son style tout employeur saura si vous êtes professionnel ou non.

Le créateur du langage C, Brian Kernighan nous dit ceci à propos du style : "le code sera simple et limpide - logique claire et évidente, expressions naturelles, utilisation d’un langage conventionnel, noms compréhensibles et significatifs, formatage impeccable, commentaires utiles - et évitera les spécificités soi-disant astucieuses ainsi que les constructions inhabituelles. Il est important de rester cohérent car les tierces personnes trouveront ainsi votre code plus lisible - et vous aurez le même avis pour le leur - si vous faites tout sur le même modèle." (KERNIGHAN, La programmation en pratique, p.2).

2. Typographie et choix des noms

L’idéal est un nom concis, facile à retenir, si possible prononçable et qui donne la bonne information concernant une variable, une fonction ou tout objet que vous créez dans le programme. De façon cohérente donnez aux objets apparentés des noms similaires avec éventuellement précision sur les relations qui existent...