La structure répétitive
sommaire du chapitre :
En C, nous disposons de trois structures qui nous permettent la définition
de boucles conditionnelles:
1) la structure : while
2) la structure : do - while
3) la structure : for
Théoriquement, ces structures sont interchangeables, cad. il serait possible
de programmer toutes sortes de boucles conditionnelles en n'utilisant qu'une
seule des trois structures. Comme en Pascal, il est quand même absolument recommandé
de choisir toujours la structure la mieux adaptée au cas actuel (voir chapitre
4.).
La structure while correspond tout à fait à la structure "tant que" du langage algorithmique (si on néglige le fait qu'en C les conditions peuvent être formulées à l'aide d'expressions numériques).
La structure tant que en langage algorithmique
TantQue (
Faire <Instructions>
FinTantQue
La structure tant que en C
while(<Expression Logique>)
{<Instructions>}
-Tant que <Expression Logique> renvoir une valeur différente de
0, les <Instructions> seront exécutées.
-Si <Expression Logique> renvoit 0, on passe à l'exécution
du reste du code.
-Les <Instructions> peuvent être exécutées 0 ou plusieurs
fois.
Remarque :Parfois nous voulons seulement attendre un certain événement, sans
avoir besoin d'un traitement de données. Dans ce cas, la partie
Exemple :
while(getch()==" ")
;
La structure do - while est semblable à la structure while,
avec les différences suivante :
-while évalue la condition avant d'exécuter le bloc d'instructions
-do - while évalue la condition après avoir exécuté le bloc d'instructions.
Ainsi le bloc d'instructions est exécuté au moins une fois.
La structure do - while en C
do {Instructions}
while (<Expression logique>)
Les <Instructions>
Exemple :
float N;
do{printf("Introduisez un nombre entre 1 et 10 :"); scanf("%f",
&N);}
while (N<1 || N>10);
La structure for en Pascal et la structure pour en langage algorithmique sont utilisées pour faciliter la programmation de boucles de comptage. La structure for en C est plus générale et beaucoup plus puissante.
La structure for en C
for(<Instructions Init for> ; <Expression Logique> ; <Instructions
for>)
{ <Instructions> }
<Expression Logique> est évaluée avant chaque passage de la boucle. Elle
est utilisée pour décider si la boucle est répétée ou non.
<Instructions for> est évaluée à la fin de chaque passage de la boucle.
Elle est utilisée pour réinitialiser les données de la boucle.
Remarque : cette structure est équivalente à :
<Instructions Init for>
while(<Expression Logique >)
{<Instructions> <Instructions for>}
Exemple :
int I;
for (I=0 ; I<=20 ; I++)
{ printf("Le carré de %d est %d \n", I, I*I); }
ATTENTION ! : En pratique, les parties
Exemple :
int n, tot;
for (tot = 0, n = 1 ; n < 101 ; n++)
{ tot = n; }
printf("La somme des nombres de 1 à 100 est %d \n", tot);
L'instruction break fait sortir de la boucle (for, while,
do, switch) dans laquelle le break est placé.
S'il y a plusieurs boucles imbriquées, on sort de la plus interne, la première
qui englobe le break .
Exemple :
int i = 0;
while(1) /* On peut passer une expression logique qui renvoit toujours VRAI
(soit 1) */
{
i++ ;
if ( i >10 ) break; /* on quitte la boucle apres 10 passages */
}
/* a la fin, i vaudra 10 */
L'instruction continue est proche de l'instruction break.
continue termine l'exécution courante de la boucle, fait évaluer la condition
de boucle et exécuter le prochain tour si la condition est vraie.
En fait continue fait sauter par-dessus les instructions qui restent
jusqu'à la fin de la boucle et reprendre à la fin de l'exécution courante.
Exemple :
int i = 0;
while(i<15)
{
i++ ;
if ( i >10 ) continue; /* on quitte la boucle apres 10 passages
et on recommence son traitement jusqu'a ce que i vaille 15*/
}
/* a la fin, i vaudra 15 */
C permet le goto tant décrié, car source de nombreuses erreurs quand
il est mal utilisé...
Il faut évidemment l'éviter le plus possible, mais il est utile lorsque l'on
génère des programmes C à partir de pré-compilateurs et dans certains cas précis
(automates...).
Exemple :
int i = 0;
label :
printf("numero : %d",i++);
if(i<10) goto label;
Remarque : On ne peut pas sauter à l'intérieur d'une boucle ou d'une procédure.
6. Choix de structure répétitive
Dans ce chapitre, nous avons vu trois façons différentes de programmer des
boucles (while, do - while, for).
Utilisez la structure qui reflète le mieux l'idée du programme que vous voulez
réaliser, en respectant toutefois les directives suivantes :
-Si le bloc d'instructions ne doit pas être exécuté si la condition est fausse,
alors utilisez while ou for.
-Si le bloc d'instructions doit être exécuté au moins une fois, alors utilisez
do - while.
-Si le nombre d'exécutions du bloc d'instructions dépend d'une ou de plusieurs
variables qui sont modifiées à la fin de chaque répétition, alors utilisez for.
-Si le bloc d'instructions doit être exécuté aussi longtemps qu'une condition
extérieure est VRAI (exemple : aussi longtemps qu'il y a des données dans le
fichier d'entrée), alors utilisez while.