On appelle instruction de contrôle toute instruction qui permet de contrôler le fonctionnement d'un programme. Parmi les instructions de contrôle, on distingue les instructions de branchement et les boucles. Les instructions de branchement permettent de déterminer quelles instructions seront exécutées et dans quel ordre.
1. Les instructions de branchement conditionnel
1.1. Branchement conditionnel if---else
La forme la plus générale est celle-ci :
if (expression-1 )
instruction-1
else if (expression-2 )
instruction-2
...
else if (expression-n )
instruction-n
else
instruction-¥
avec un nombre quelconque de else if ( ... ). Le dernier else est toujours facultatif. La forme la plus simple est
if (expression ) instruction
Chaque instruction peut être un bloc d'instructions.
1.2. Branchement multiple switch
Sa forme la plus générale est celle-ci :
switch (expression )
{case constante-1:
liste d'instructions 1
break;
case constante-2:
liste d'instructions 2
break;
...
case constante-n:
liste d'instructions n
break;
default:
liste d'instructions ¥
break;
}
Si la valeur de expression est égale à l'une des constantes, la liste d'instructions correspondant est exécutée. Sinon la liste d'instructions ¥ correspondant à default est exécutée. L'instruction default est facultative.
2. Les boucles
Les boucles permettent de répéter une série d'instructions tant qu'une certaine condition n'est pas vérifiée.
2.1. Boucle while
La syntaxe de while est la suivante :
while (expression ) instruction
Tant que expression est vérifiée (i.e., non nulle), instruction est exécutée. Si expression est nulle au départ, instruction ne sera jamais exécutée. instruction peut évidemment être une instruction composée. Par exemple, le programme suivant imprime les entiers de 1 à 9.
i = 1;
while (i < 10)
{
printf("\n i = %d",i);
i++;
}
2.2. Boucle do---while
Il peut arriver que l'on ne veuille effectuer le test de continuation qu'après avoir exécuté l'instruction. Dans ce cas, on utilise la boucle do---while. Sa syntaxe est
do instruction while (expression );
Ici, instruction sera exécutée tant que expression est non nulle. Cela signifie donc que instruction est toujours exécutée au moins une fois.
Par exemple, pour saisir au clavier 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));
2.3. Boucle for
La syntaxe de for est :
for (expr 1 ;expr 2 ;expr 3) instruction
Une version équivalente plus intuitive est :
expr 1;
while (expr 2 )
{instruction
expr 3;
}
Par exemple, pour imprimer tous les entiers de 0 à 9, on écrit :
for (i = 0; i < 10; i++)
printf("\n i = %d",i);
A la fin de cette boucle, i vaudra 10. Les trois expressions utilisées dans une boucle for peuvent être constituées de plusieurs expressions séparées par des virgules. Cela permet par exemple de faire plusieurs initialisations à la fois. Par exemple, pour calculer la factorielle d'un entier, on peut écrire :
int n, i, fact;
for (i = 1, fact = 1; i <= n; i++)
fact *= i;
printf("%d ! = %d \n",n,fact);
On peut également insérer l'instruction fact *= i; dans la boucle for ce qui donne :
int n, i, fact;
for (i = 1, fact = 1; i <= n; fact *= i, i++);
printf("%d ! = %d \n",n,fact);
On évitera toutefois ce type d'acrobaties qui n'apportent rien et rendent le programme difficilement lisible.
3. Les instructions de branchement non conditionnel
3.1. Branchement non conditionnel 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. Elle permet d'interrompre le déroulement de la boucle, et passe à la première instruction qui suit la boucle. En cas de boucles imbriquées, break fait sortir de la boucle la plus interne.
Par exemple, le programme suivant :
main()
{
int i;
for (i = 0; i < 5; i++)
{
printf("i = %d\n",i);
if (i == 3)
break;
}
printf("valeur de i a la sortie de la boucle = %d\n",i);
}
imprime à l'écran
i = 0 i = 1 i = 2 i = 3 valeur de i a la sortie de la boucle = 3
3.2 Branchement non conditionnel continue
L'instruction continue permet de passer directement au tour de boucle suivant, sans exécuter les autres instructions de la boucle. Ainsi le programme
main()
{
int i;
for (i = 0; i < 5; i++)
{
if (i == 3)
continue;
printf("i = %d\n",i);
}
printf("valeur de i a la sortie de la boucle = %d\n",i);
}
imprime
i = 0 i = 1 i = 2 i = 4 valeur de i a la sortie de la boucle = 5
3.3. Branchement non conditionnel goto
L'instruction goto permet d'effectuer un saut jusqu'à l'instruction etiquette correspondant.
2017-10-15 15:59:35 / mazoughou@magoe.gn
0 commentaires
Votre impression compte aussi