Dans cette partie nous étudions une nouvelle forme de structure de
contrôle:
les boucles itératives.
Supposons que l'on ait envie de calculer la somme des n premier entiers:
1 + 2 + 3 + .. + n, pour un nombre n entier
positif et quelconque.
Une manière, est de commencer par ajouter 2 à 1,
puis d'ajouter 3 à ce résultat, ensuite 4,
et de continuer ainsi jusqu'à n. Cette méthode décrit
un processus de repétition que l'on dit itératif et que l'on
peut cristalliser en programmation à l'aide d'une
boucle itérative. Les actions que l'on cherche
à itérer ici aboutissent
au calcul incrémental de la somme 1 + 2 + 3 + .. + n.
Formalisons davantage notre exemple. On se donne
deux valeurs: compteur et somme_courante. On
décrira le calcul en disant d'une part, que ces deux valeurs
varient simultanément à chaque tour de boucle, et d'autre part,
en décrivant
comment elles changent. La valeur de compteur
est incrémentée de 1
à chaque étape: d'une valeur initiale de
0, elle passe à 1, puis à 2, etc. La variable
somme_courante
accumule la somme calculée après un certain nombre d'itérations.
Les changements d'une étape à la suivante sont données par la
règle:
compteur |
![]() |
somme_courante |
![]() |
On veut donc repéter ces deux actions tant que cela sera nécesaire au
calcul. Dans notre cas, jusqu'à ce que compteur prenne la valeur n.
Il est évident que les simples instructions d'affectation, séquence
et branchement ne suffisent pas à écrire un programme qui répète ces
actions.
Les boucles itératives que nous étudions sont
des constructions syntaxiques permettant l'itération d'une séquence
d'instructions.