Structures de contrôle en C

• Elle permettent de déterminer quelles instructions seront exécutées et dans quel ordre.
• Branchement conditionel ( if…else) :

if (expression) {bloc-instruction-1}

else {bloc-instruction-2}

• Après évaluation de l’expression, si elle est vraie, alors le 1er bloc d'instructions est exécuté, sinon c'est le 2ème bloc qui est exécuté.
• La partie else est optionnelle, lorsque plusieurs instructions if sont imbriquées, chaque else se rapporte au dernier if qui ne possède pas de partie else.
  • Exemple :

If (a>10)   { b=11; c=12; }

Branchement multiple ( switch)

• •   On l’appelle aussi l'instruction d'aiguillage. Elle teste si une expression entière prend une valeur parmi une suite de constantes entières, et effectue le branchement correspondant si c'est le cas.
• Format :

switch ( expression )

{

case expression_constante1 : suite d'instructions 1 case expression_constante2 : suite d'instructions 2

...

case expression_constanteN : suite d'instructions N default : suite d'instructions

}

• Fonctionnement :
  • Après l’évaluation de l’expression, s'il existe un énoncé case avec une constante = expression, le contrôle est transféré à l'instruction qui suit cet énoncé;
  • sinon si l’énoncé default existe, alors le contrôle est transféré à l'instruction qui suit l'énoncé default ;
  • si la valeur de expression ne correspond à aucun énoncé case et s'il n'y a pas d'énoncé default, alors aucune instruction n'est exécutée.
  • Attention. Lorsqu'il y a branchement réussi à un case, toutes les instructions qui le suivent sont exécutées, jusqu'à la fin du bloc ou jusqu'à une instruction de rupture (break).

Exemple :

#include <stdio.h> main()
{	short a,b ,
char operateur ;
printf("Entrez un opérateur (+, -, * ou /) : ") ;
scanf("%c", &operateur) ; printf("Entrez deux entiers : ") ;
 scanf("%hd %hd", &a,&b) ; switch (operateur)
{ case '+' : printf("a + b = %d\n",a+b) ; break ;
 case '-'  : printf("a - b = %d\n",a-b) ; break ;
 case '*' : printf(" a * b = %d\n",a*b) ; break ;
 case '/' : printf("a / b = %d\n",a/b) ; break ;
 default  : printf("opérateur inconnu\n") ;
}
return 0 ;

• Les structures répétitives (ou Boucles) permettent de répéter une série d’instructions tant qu’une certaine condition reste vraie.
• Les instructions while et do…while
• Les instructions while et do … while représentent un moyen d'exécuter plusieurs fois la même série d'instructions.
• La syntaxe :

• while ( condition )

  {            liste d'instructions}

   

  do {         liste d'instructions

  } while ( condition );

14. • Dans la structure while on vérifie la condition avant d’exécuter la liste d’instructions, tandis que dans la structure do … while on exécute la liste d’instructions avant de vérifier la condition

• Les instructions while et do…while
• Exemple :

1.	Code C pour imprimer les entiers de 1 à 9.

i = 1;

while (i < 10)
{
printf("\n i = %d",i); i++;
}

2. Code C pour contrôler la saisie au clavier d’un entier entre 1 et 10 :
int a; do
{
printf("\n Entrez un entier entre 1 et 10 : "); scanf("%d",&a);
}
while ((a <= 0) || (a > 10));

L’ instructions for

• permet d'exécuter plusieurs fois la même série d'instructions.

• La syntaxe de for est :

• for ( expression1 ; expression2 ; expression3 )

  {

  liste d'instructions       }

14. • Dans la construction de for :
      • expression1 : effectue les initialisations nécessaires avant l’entrée dans la boucle ;
      • expression2 : est le test de continuation de la boucle ; le test est évalué avant l’exécution du corps de la boucle;
      • expression3 : est évaluée à la fin du corps de la boucle.

Exemple : 

1. Programme pour calculer la somme de 1 à 100 : short n, total ;
for ( total = 0, n = 1 ; n<101 ; n++ ) total += n ;

printf("La somme des nombres de 1 à 100 est %d\n", total) ;

• L’ instructions break
• On a vu le rôle de l'instruction break; au sein d'une instruction de branchement multiple switch.

L'instruction break peut, plus généralement, être employée à l'intérieur de n'importe quelle boucle (for ; while ; do …while ). Elle permet l’abandon de la structure et le passage à la première instruction qui suit la structure.

En cas de boucles imbriquées, break fait sortir de la boucle la plus interne.

Exemple

for ( ; ; )
{
printf("donne un nombre (0 pour sortir) : "); scanf("%d", &n);
if (n == 0) break;
exploitation de la donnée
}

1. • L’ instructions continue
   • L'instruction continue peut être employée à l'intérieur d’une structure de type boucle (for ; while ; do …while ).
   • Elle produit l’abandon de l’itération courante et fait passer directement à l’itération suivante d’une boucle
   • L’instruction continue concerne la boucle la plus proche.

Exemple :