Les boucles

Avatar de Monsieur X
Description du chapitre et des ses objectifs :

Attention, voila un gros chapitre. Il est capital de bien comprendre la notion de boucle, car tous les programmes fonctionnent sur leur principe. Il s'agit en effet de répéter des tâches autant de fois qu'on le désire. Après ce chapitre, prennez donc bien le temps de vous entraîner, c'est la base de l'algorithmie. J'espère que vous apprécierez donc ce chapitre dans toute sa longueur.

Image de Partie

Accéder directement à une des parties du cours :

Tant que

Comment faire pour répéter des tâches ennuyeuses ou dont on ne connaît pas la fin à l'avance? Par exemple, combien de fois allons nous recopier une ligne pour une punition? Ou même comment calculer le pgcd de 2 nombres?
C'est ce à quoi nous allons répondre. Tout d'abord, il faut se poser la question correctement:
Quand est-ce que je dois arrêter de recopier la ligne de ma punition? La réponse est "tant que je ne l'ai pas fait assez de fois".

Voyons comment matérialiser ça:
En C, la forme de boucle la plus basique est le while. while va executer un bloc d'instructions tant que sa condition est vraie.

Question : Une condition? Ca marche comme un if alors?

Exactement! A la différence près que une fois le bloc d'instruction est terminé, while va ré-évaluer sa condition pour savoir s'il doit recommencer le bloc d'instruction.

Voyons maintenant sa syntaxe:
Code c - Numéro de ligne
  1. while( /*condition*/ )
  2. {
  3.    /* faire des choses */
  4. }


Mais ça ne doit pas trop vous éclaircir. Essayons maintenant avec notre premier exemple:
Code c - Numéro de ligne
  1. int nombre_lignes = 500;
  2. int i = 0;
  3. while( i < nombre_lignes )
  4. {
  5.     printf("Je ne doit pas recopier ce qu'a écrit mon voisin\n");
  6.     i++;
  7. }

Essayez donc ce code dans un programme

Alors examinons attentivement ce que fait notre programme:
Citation :
nombre_lignes vaut 500;
i vaut 0;
tant que i est inférieur à nombre_ligne:

--------i vaut 0 et nombre_ligne vaut 500, est-ce que 0<500 => c'est vrai! J'execute le bloc d'instructions:
----------------j'affiche "Je ne doit pas recopier ce qu'a écrit mon voisin\n";
----------------j'incrémente i, i vaut maintenant 1;

--------i vaut 1 et nombre_ligne vaut 500, est-ce que 1<500 => c'est vrai! J'execute le bloc d'instructions:
----------------j'affiche "Je ne doit pas recopier ce qu'a écrit mon voisin\n";
----------------j'incrémente i, i vaut maintenant 2;

--------i vaut 2 et nombre_ligne vaut 500, est-ce que 2<500 => c'est vrai! J'execute le bloc d'instructions:
----------------j'affiche "Je ne doit pas recopier ce qu'a écrit mon voisin\n";
----------------j'incrémente i, i vaut maintenant 3;

--------i vaut 3 et nombre_ligne vaut 500, est-ce que 3<500 => c'est vrai! J'execute le bloc d'instructions:
----------------j'affiche "Je ne doit pas recopier ce qu'a écrit mon voisin\n";
----------------j'incrémente i, i vaut maintenant 4;

...
...

--------i vaut 499 et nombre_ligne vaut 500, est-ce que 499<500 => c'est vrai! J'execute le bloc d'instructions:
----------------j'affiche "Je ne doit pas recopier ce qu'a écrit mon voisin\n";
----------------j'incrémente i, i vaut maintenant 500;

--------i vaut 500 et nombre_ligne vaut 500, est-ce que 500<500 => c'est faux! Je n'execute pas le bloc d'instructions:

je sors de la boucle tant que;


Question : Remarquez vous l'importance de i qui s'incrémente?

i permet ainsi d'avoir une fin à la boucle. Si vous faites une boucle tout le temps vrai, par exemple:
Code c - Numéro de ligne
  1. while(1)
  2. {
  3.     ;
  4. }

Cette boucle n'aura pas de fin! Votre programme tournera tout le temps à cet endroit et ne fera rien d'autre!
Il faut donc éviter les boucles infinies.

Information : Si vous n'avez qu'une seule instruction à faire dans le bloc d'instruction, il est possible d'enlever les accolades, comme pour les conditions. Exemple:
Code c - Numéro de ligne
  1. while(1);
";" correspond à une instruction qui ne fait rien


Un petit exercice maintenant:
Faire une fonction qui retourne la somme des n premiers entiers. Cette fonction aura pour prototype int somme(int n).
Par exemple pour n = 4, la fonction retournera 1 + 2 + 3 + 4 = 10.

Voici une correction:
Secret (cliquez pour afficher)
Code c - Numéro de ligne
  1. int somme(int n)
  2. {
  3.     int i = 0, resultat = 0;
  4.     while( i <= n)
  5.     {
  6.          resultat = resultat + i;
  7.          i++;
  8.     }
  9.     return resultat;
  10. }


Regardons ce que fait l'algorithme de près, pour cela on peut regarder sous la forme d'un tableau avec n=5:
Code - Numéro de ligne
  1. |  i=  |  resultat=  |  n=  |
  2. |  0   |     0       |  5   |  //initialisation, est-ce que i <= n: oui => on entre dans la boucle
  3. |  1   |     0       |  5   |  //1&deg; tour de boucle, est-ce que i <= n: oui => on réitère dans la boucle
  4. |  2   |     1       |  5   |  //2&deg; tour de boucle, est-ce que i <= n: oui => on réitère dans la boucle
  5. |  3   |     3       |  5   |  //3&deg; tour de boucle, est-ce que i <= n: oui => on réitère dans la boucle
  6. |  4   |     6       |  5   |  //4&deg; tour de boucle, est-ce que i <= n: oui => on réitère dans la boucle
  7. |  5   |     10     |  5   |  //5&deg; tour de boucle, est-ce que i <= n: oui => on réitère dans la boucle
  8. |  6   |     15     |  5   |  //5&deg; tour de boucle, est-ce que i <= n: NON => on sort de la boucle
  9. Je retourne enfin resultat, soit 15 pour n = 5



Information : Je vous conseille lorsque vous codez d'avoir toujours sous la main une feuille de papier pour faire un tableau de la sorte et vérifier à chaque tour de boucle si vous avez les bonnes valeurs, c'est capital pour avancer en algorithmie.

Faire tant que ou répéter jusqu'à

Il existe une autre forme pour la boucle while, le do..while. Cela revient à peu près au même, à la différence près que le bloc d'instruction sera executé une première fois indépendament de la condition du while.
Voici sa syntaxe:

Code c - Numéro de ligne
  1. do
  2. {
  3.    /*instructions*/
  4. }while( /*condition*/ );


Attention : Dans le cas d'un do..while il y a un ";" après le while ! Faites attention à ne pas l'oublier. (par contre, je rappelle qu'il n' y a pas de ";" dans le cas d'un while classique.


Un petit exemple pour voir le fonctionnement:
Code c - Numéro de ligne
  1. int valeur = 5;
  2. do
  3. {
  4.    valeur += 10;
  5. }while(valeur < 3);

Voilà le déroulement de la boucle:
Citation :
valeur vaut 5;
on entre dans la boucle:
---valeur vaut 5 + 10 = 15
---valeur n'est pas inférieure à 3, donc on ne recommence pas la boucle
on sort de la boucle et valeur vaut 15.

La boucle for

La dernière forme de boucle utilise le mot clef for. Celle-ci est un peu différente des 2 autres. En effet, elle permet l'initialisation de variables, le test de condition après chaque tour (et bien sur avant d'entrer) et enfin d'automatiser ce qu'il se passe à chaque fin de boucle (comme une incrémentation).
Voici sa syntaxe:

Code c - Numéro de ligne
  1. for(<initialisation>;<condition>;<chose a faire à chaque fin de tour de boucle>
  2. {
  3.    /* instructions */
  4. }

Attention : Pour séparer les membres d'un for on utilise des ";". Il faut toujours que les 2 ; soient présents.

Ce genre de boucle est avant tout utilisé lorsque l'on connait la valeur de fin de la boucle, souvent un chiffre fixe. Cela est utile pour des compteurs par exemple. Les règles du for sont les mêmes qu'un while à la différence près de l'initialisation et de ce que l'on peut faire à chaque fin de tour de boucle (ce qui est donc avant tout une question de lisibilitée. Bien entendu, l'initialisation ne se fait à l'entrée de la boucle et avant le test de la condition.
Pour récapituler:
- J'entre dans le for et j'exécute les premières instructions du début du champ
- J'évalue si la condition est vraie, si oui j'entre dans la boucle
--- J'exécute les instructions
--- J'exécute les instructions dans le 3° champ du for qui se fait à la fin d'un tou de boucle
- J'évalue si la condition est encore vraie, si oui j'entre dans la boucle
--- Etc...


Voici un rapide exemple:
Code c - Numéro de ligne
  1. int i;
  2. for(i = 0; i < 10; i++)
  3. {
  4.    printf("Valeur en cours=%d\n", i);
  5. }


Les possibilitées sont nombreuses! Il est même possible de faire une boucle dans une boucle... et ainsi de suite.

Information : Tout comme pour les autres boucles, s'il n'y a qu'une seule instruction à effectuer, il est possible d'enlever les accolades.


Enfin, il est possible de mettre plusieurs instructions d'initialisation et de fin de boucle en les séparant par des ",".
Exemple:
Code c - Numéro de ligne
  1. int a,b,i;
  2. for(a = 10, b = 5, i = 0; i < 10 ; a -= b, i++) ;

Ce code est assez inutile, mais il est important de comprendre ce qu'il fait. Entraînez vous comme je vous l'ai montré avec un tableau en suivant ce que font chacune des variables à chaque tour de boucle.

Question : Ha ben il n'était pas si long que ça!

Effectivement, mais les notions sont très importantes, allez vous exercez dans la section d'exercices correspondants, vous verrez que c'est plus dur dans la pratique! Maintenant, il va falloir apprendre à mettre des boucles quand il le faut! En informatique, on se base toujours sur un principe: regarder comment on fait le minimum pour laisser la machine le répéter, à vous de jouer.

Chapitre précédent - Sommaire

Nos rédacteurs et membres sont pour la plupart ouverts à des remarques constructives et servir à alerter le rédacteur du cours, des fautes éventuelles ou de propositions et nouvelles perspectives de cours etc ...
Pour ce faire cliquez ici

Postez vous aussi un commentaire à cette partie via le lien que voici