Intéressé par des cours d'informatique en ligne ?
Visitez mon nouveau site
https://www.yesik.it !
Sommaire
Introduction à la programmation Dans un langage impératif, une boucle est une structure de contrôle qui permet de répéter une même portion de code appelée corps de la boucle. Chaque exécution du corps de la boucle est appelée une itération.
Il existe plusieurs types de boucles qui diffèrent par la manière de contrôler le nombre d'itérations à effectuer.
Comme leur nom l'indique, dans les boucles conditionnelles, le nombre de répétition effectuées est déterminé par une condition. Dans les langages dérivés du C, il existe deux types de boucles conditionnelles: les boucles faire .. tant que et les boucles tant que ... faire. Elles diffèrent par le moment où la condition est évaluée.
tant que ... faire
La boucle tant que ... faire sert à répéter un fragment de code tant qu'une condition est vraie. La condition est évaluée avant chaque itération. Cela implique donc que si la condition n'est pas validée dès l'arrivée sur la boucle, le corps n'est jamais effectué.
Syntaxe
Dans les langages de la famille du C, la syntaxe générale d'une boucle tant que ... faire est la suivantes:
while(condition) {
corps de la boucle
}
Note:
Si le corps de la boucle ne contient qu'une seule instruction, les accolades sont optionnelles.
Ainsi, les deux boucles suivantes sont absolument identiques:
while(condition) {
instruction ;
}
et
while(condition) instruction ;
Néanmoins on considère qu'il est généralement de meilleur style de toujours mettre les accolades pour éviter des erreurs comme celle-ci:
while(condition) instruction 1 ; instruction 2 ;
Ici, comme l'identation le laisse supposer, le programmeur veut certainement répéter les deux instructions dans la boucle. Cependant, comme il a oublié les accolades, seule linstruction 1 fait effectivement partie du corps de la boucle. Linstruction 2 est donc à l'extérieure de cette dernière et est donc toujour sexécutée une et une seule fois.
Ce genre de bug peut facilement être intruduit lors d'une modification du code.
Exemple
Nous illustrer le fonctionnement de la boucle tant que ... faire en nous appuyant sur un fragment de code effectuant une simulation discrète du mouvement d'un mobile douté d'une vitesse initiale et soumis uniquement à la force de gravitation.
L'algorithme est très simple:
initialisation des valeurs de départ
TANT QUE le mobile n'a pas touché le sol
FAIRE
afficher la position actuelle
calculer la nouvelle vitesse
calculer la nouvelle position
FIN
Le résultat de ce programme peut ensuite être utilisé dans un tableur pour produire un graphique comme celui ci-contre.
En C/C++
Le fragment de code C qui correspond à notre exemple est le suivant:
/* ... */ /* initialisation des valeurs de départ */ Speed currentSpeed = initialSpeed; Position currentPosition = origin; /* TANT QUE le mobile n'a pas touché le sol */ while(currentPosition.y >= 0) { /* afficher la position actuelle */ printf("%0.2lf %0.2lf\n", currentPosition.x, currentPosition.y); /* calculer la nouvelle vitesse */ currentSpeed.y -= gravity; /* calculer la nouvelle position */ currentPosition.x += currentSpeed.x; currentPosition.y += currentSpeed.y; } /* ... */
Le fragment de code ci-dessous calcule la position en fonction de ses vitesse et position initialés et de la force de gravitation qui s'applique à lui.
Le fragment de code ci-dessous boucle tant qu'un mobile n'a pas atteint le sol (currentPosition.y >= 0) et à chaque itération affiche la position actuelle du mobile, et calcule sa position une unité de temps plus tard.
Le résultat de ce programme peut ensuite être utilisé dans un tableur pour produire un graphique comme celui ci-contre.
void shoot(Position origin, Speed initialSpeed, double gravity) { Speed currentSpeed = initialSpeed; Position currentPosition = origin; /* * Boucle tant que le mobile n'a pas * atteint le sol. */ while(currentPosition.y >= 0) { printf("%0.2lf %0.2lf\n", currentPosition.x, currentPosition.y); currentSpeed.y -= gravity; currentPosition.x += currentSpeed.x; currentPosition.y += currentSpeed.y; } }
#include <stdio.h> /** * Cette fonction calcule la première puissance de 2 * suppérieure (strictement) à un entier donné. */ long lowestPowerOfTwoGreaterThan(unsigned long limit) { long result = 1; while(result <= limit) { result = result*2; } return result; } /** * Programme de test. */ int main() { long limit = 100; printf("lp2gt %ld is %ld\n", limit, lowestPowerOfTwoGreaterThan(limit)); return 0; }
Boucle jusqu'à ce que
Description
La boucle jusqu'à ce que sert à répéter un fragment de code jusqu'à ce que la condition est vraie. La condition est évaluée avant chaque itération. Cela implique que si la condition n'est pas validée dès l'arrivée sur la boucle, le corps n'est jamais effectué.
Boucle pour
La boucle pour est utilisée quand le nombre d'itération est connue avant le début de la boucle. Elle est généralement utilisée pour parcourir des tableaux.
La boucle pour utilise une variable de boucle afin de connaître l'itération acutelle.
Remarque:
La tradition veut qu'on utilise la variable i comme variable de boucle. C'est une des rares exceptions largement admise à l'utilisation de nom significatifs pour les variables.
La syntaxe de la boucle for est la suivante:
for(initialisation; condition; incrément) {
corps de la boucle
}
for .vs. while
Dans les langages issus du C, la boucle for est en fait une variante de la boucle tant que ... faire.
Ainsi, dans ces langages, les deux boucles ci-dessous sont rigoureusement identiques: La syntaxe de la boucle for est la suivante:
for(initialisation; condition; incrément) {
corps de la boucle
}
initialisation
while(condition) {
corps de la boucle
incrément
}
