Cours complet pour apprendre à programmer en D

La boucle while évalue la condition et continue d'exécuter la boucle tant que la condition est vraie. Par exemple, une boucle pour afficher les nombres entre 1 et 10 peut vérifier la condition « inférieur à 11 » :

while (nombre < 11)

Itérer la boucle peut être fait en incrémentant un compteur à la fin de la boucle :

++nombre;

Pour être compilable en D, nombre doit avoir été défini avant sa première utilisation :

int nombre = 1;

Finalement, il y a ce qui est effectivement fait dans le corps de la boucle :

writeln(nombre);

Ces quatre sections peuvent être définies comme dans les commentaires ci-après :

int nombre = 1;         // ← préparation
 
while (nombre < 11) {   // ← vérification de la condition
   writeln(nombre);     // ← travail de la boucle
   ++nombre;            // ← itération
}

Les sections d'une boucle while sont exécutées dans l'ordre suivant pendant l'itération de la boucle while :

préparation
 
vérification de la condition
travail de la boucle
itération
 
vérification de la condition
travail de la boucle
itération
 
...

Une instruction break ou une exception levée peut également terminer la boucle.

for regroupe trois de ces sections sur une seule ligne. Elles sont écrites à l'intérieur des parenthèses de la boucle for, séparées par des points-virgules. Le corps de la boucle ne contient que ce que la boucle fait :

for (/* préparation */; /* condition */; /* itération */) {
   /* travail de la boucle */
}

Le même code est plus cohérent quand il est écrit avec une boucle for :

for (int nombre = 1; nombre < 11; ++nombre) {
   writeln(nombre);
}

L'avantage de la boucle for est plus évident quand le code de la boucle a un grand nombre d'instructions. L'expression qui incrémente la variable d'itération est visible sur la ligne for au lieu d'être mélangée avec les autres instructions de la boucle.

Les sections de la boucle for sont exécutées dans le même ordre que la boucle while.

Les instructions break et continue fonctionnent exactement de la même façon dans la boucle for.

La seule différence entre les boucles while et for est l'espace de noms de la variable d'itération. Ceci est expliqué ci-dessous.

Bien que ce soit généralement le cas, la variable d'itération n'a pas à être un entier, et n'est pas forcément modifiée par une opération d'incrémentation. Par exemple, la boucle suivante est utilisée pour afficher les moitiés des valeurs flottantes précédentes :

for (double valeur = 1; valeur > 0.001; valeur /= 2) {
   writeln(valeur);
}

for ({ int i = 0; double d = 0.5; } i < 10; ++i) {
   writeln("i: ", i, ", d: ", d);
   d /= 2;
}

Notez que la section de préparation est la partie entre les accolades qui sont entre les parenthèses et qu'il n'y a pas de point-virgule entre la section de préparation et la section de condition.

Les trois sections de la boucle for peuvent être laissées vides.

• Parfois une variable d'itération n'est pas nécessaire, par exemple parce qu'une variable déjà définie est utilisée.
• Parfois la sortie de la boucle peut se faire au moyen d'une instruction break au lieu d'être basée sur la condition de boucle.
• Parfois les expressions d'itération dépendent de certaines conditions qui seront vérifiées dans le corps de la boucle.

Quand toutes les sections sont vides, la boucle for correspond à une boucle infinie :

for ( ; ; ) {
   // ...
}

Une telle boucle peut être utilisée pour ne jamais finir ou finir avec une instruction break.

La seule différence entre la boucle for et la boucle while est l'espace de noms de la variable définie pendant la préparation de la boucle : la variable n'est accessible qu'à l'intérieur de la boucle, et non à l'extérieur :

for (int i = 0; i < 5; ++i) {
   // ...
}
 
writeln(i);   // ← Erreur de compilation
              //   i n'est pas accessible ici

En revanche, quand la variable est définie dans l'espace de noms qui contient la boucle while, le nom est accessible même après la boucle :

int i = 0;
 
while (i < 5) {
   // ...
   ++i;
}
 
writeln(i);   // ← Ça fonctionne ; i est accessible ici

Nous avons vu le conseil de définir les noms le plus près possible de leur première utilisation dans le chapitre précédent. De façon similaire, plus l'espace de noms d'une variable est petit, mieux c'est. De ce fait, quand la variable d'itération n'est pas utilisée hors de la boucle, for est mieux que while.

1. Afficher le tableau 9×9 suivant en utilisant deux boucles for, l'une à l'intérieur de l'autre :
   
2. Utiliser une ou plusieurs boucles for pour afficher le caractère * de façon à produire des formes géométriques :

Les solutionsLa boucle for - Correction.