Nous souhaitons créer un programme qui nous affiche tous les nombres de 1 à 10, donc dont l’exécution serait la suivante :
1 2 3 4 5 6 7 8 9 10
Une façon particulièrement vilaine de procéder serait d’ecrire 10
Console.WriteLine successifs, avec la laideur des
copier/coller que cela impliquerait. Nous allons étudier un moyen de
coder ce type de programme avec un peu plus d’élégance.
Une boucle permet d’exécuter plusieurs fois de suite une même séquence d’instructions. Cette ensemble d’instructions s’appelle le corps de la boucle. Chaque exécution du corps d’une boucle s’appelle une itération, ou plus informellement un passage dans la boucle. Lorsque l’on s’apprête à exécuter la première itération, on dit que l’on rentre dans la boucle, lorsque la dernière itération est terminée, on dit qu’on sort de la boucle. Il existe trois types de boucle :
while
do ... while
for
Chacune de ces boucles a ses avantages et ses inconvénients. Nous les passerons en revue ultérieurement.
whileEn C#, la boucle tant que se code de la façon suivante :
| while(<condition>) { <instructions> } |
Les instructions du corps de la boucle sont délimitées par des accolades. La condition est évaluée avant chaque passage dans la boucle, à chaque fois qu’elle est vérifiée, on exécute les instructions de la boucle. Un fois que la condition n’est plus vérifiée, l’exécution se poursuit après l’accolade fermante. Affichons par exemple tous les nombres de 1 à 5 dans l’ordre croissant,
| public static void Main (string[] args) { int i = 1; while (i <= 5) { Console.Write(i + " "); i++; } Console.Write("\n"); } |
Ce programme initialise i à 1 et tant que la valeur de
i n’éxcède pas 5, cette valeur est affichée puis incrémentée. Les
instructions se trouvant dans le corps de la boucle sont donc
exécutées 5 fois de suite. La variable i s’appelle un
compteur, on gère la boucle par incrémentations successives
de i et on sort de la boucle une fois que i a atteint une
certaine valeur. L’initialisation du compteur est très
importante ! Si vous n’initialisez pas i explicitement, alors cette
variable contiendra n’importe quelle valeur et votre programme ne se
comportera pas du tout comme prévu. Notez bien par ailleurs qu’il n’y
a pas de point-virgule après le
while !
do ... whileVoici la syntaxe de cette boucle :
| do { <instructions> } while(<condition>); |
La fonctionnement est analogue à celui de la boucle tant que à quelques détails près :
En C, la boucle répéter ... jusqu’à est en fait une boucle
répéter ... tant que, c’est-à-dire une boucle tant
que dans laquelle la condition est évaluée à la fin.
Une boucle
do ... while est donc exécutée donc
au moins une fois. Reprennons l’exemple précédent avec une
boucle
do ... while :
| public static void Main (string[] args) { int i = 1; do { Console.Write(i + " "); i++; } while (i <= 5); Console.Write("\n"); } |
De la même façon que pour la boucle
while, le compteur est
initialisé avant le premier passage dans la boucle. Un des usages les
plus courant de la boucle
do ... while est le contrôle
de saisie :
| public static void Main (string[] args) { int i; do { Console.Write("Saisissez un entier positif ou nul : "); i = int.Parse(Console.ReadLine()); if (i < 0) Console.WriteLine("J'ai dit positif ou nul !"); } while (i < 0); Console.WriteLine("Vous avez saisi " + i + "."); } |
forCette boucle est quelque peu délicate. Commençons par donner sa syntaxe :
| for(<initialisation> ; <condition> ; <pas>) { <instructions> } |
L’<initialisation> est une instruction exécutée avant le
premier passage dans la boucle. La <condition> est évaluée
avant chaque passage dans la boucle, si elle n’est pas
vérifiée, on ne passe pas dans la boucle et l’exécution de la boucle
pour est terminée. La <pas> est une instruction exécutée
après chaque passage dans la boucle. On peut convertir une
boucle
for en boucle
while en procédant de la sorte :
| <initialisation> while(<condition>) { <instructions> <pas> } |
On re-écrit l’affiche des 5 premiers entiers de la sorte en
utilisant le fait que <initialisation> =
i = 1,
<condition> =
i <= 5 et <pas> =
i++. On obtient :
| public static void Main (string[] args) { for (int i = 1; i <= 5 ;i++) { Console.Write(i + " "); } Console.Write("\n"); } |
On utilise une boucle
for lorsque l’on connait en entrant
dans la boucle combien d’itérations devront être faites. Par exemple,
n’utilisez pas une boucle pour pour contrôler une saisie !
De la même façon qu’il est possible de supprimer des accolades autour
d’une instruction d’un bloc
if, on peut supprimer les
accolades autour du corps d’une boucle si elle ne contient qu’une
seule instruction.