C_facile : Introduction au langage C
Cours

Boucles à bornes non définies

Lorsque le nombre d'itérations qu'effectuera la boucle n'est pas connu d'avance ou que le pas est variable, il existe deux autres types de boucles que l'on présente ainsi en langage algorithmique :

SyntaxeSyntaxe de la boucle 1 :

Syntaxe de la boucle 1 :

tant que <condition logique est vraie> faire

<bloc d'instructions>

SyntaxeSyntaxe de la boucle 2 :

faire

<bloc d'instructions>

Tant que <condition logique est vraie>

Dans les deux cas la <condition logique> permet de tester des valeurs de variables.

Dans le cas de la boucle « tant que ... faire », si la <condition logique> est initialement fausse, le bloc d'instructions ne sera pas effectué. En effet, le test est effectué avant de déclencher l'exécution du bloc d'instructions.

Dans le cas de la boucle « faire ... tant que », le bloc d'instructions est effectué avant le test. Le bloc sera donc exécuté au moins une fois.

Exemple

Traitons de nouveau l'affichage des valeurs 0, 1 et 2 avec ces deux nouvelles boucles.

Solution boucle « tant que ... faire »:

i=0 ;

tant_que (i<3)

debut

afficher(i)

i = i+1

fin

instruction_après

Présentation de l'organigramme associé :

Schéma de la boucle while
Schéma de la boucle while[Zoom...]

Pour exécuter cette boucle à la main (instruction par instruction), il suffit de suivre l'organigramme, de dessiner un rectangle (formellement un réceptacle), de le nommer i (identificateur) et d'y noter/effacer les valeurs successives de la variable i (identificateur, réceptacle).

Nous affichons 0, 1 et 2. Après la boucle, i vaut 3 comme dans le cas de la boucle « pour ». La boucle correspond au rectangle en pointillé. Les rectangles de « pour » et « tant_que faire » ne recouvrent pas les mêmes éléments.

Dans le cas de « tant que ... faire » nous remarquons que l'instruction faisant évoluer la valeur de la variable de contrôle de boucle fait désormais partie intégrante du bloc d'instructions exécutées à chaque itération de la boucle « tant_que ».

Le programmeur doit écrire des instructions pour faire évoluer les valeurs des variables sur lesquelles porte le test de sortie de boucle.

Solution du même problème avec une boucle "faire ... tant que" avec syntaxe algorithmique :

boucle do
boucle do[Zoom...]

instruction_avant i=0 ; faire début afficher(i) i = i + 1 fin tant_que (i<3) instruction_après

Présentation de l'organigramme associé :

Là encore une exécution à la main permet d'en appréhender le fonctionnement. Nous affichons 0, 1 et 2. Après la boucle i vaut 3 comme dans le cas de la boucle "pour".

Instructions « for » (page suivante)Boucles à bornes définies (page Précédente)
AccueilImprimer creativecommons : by-nc-ndRéalisé avec SCENARI