Savez-vous comment compter et énumérer des choses ? Savez-vous comment trier une liste d’objets ? Tous ces besoins, et bien d’autres, ont un point commun : ils ont besoin d’une boucle ! Je vous propose donc de voir en détail comment fonctionnent les boucles.

Les boucles, et les instructions conditionnelles sont les deux piliers de l’algorithmique. Sans eux, nous ne pourrions pas faire grand-chose.

Les instructions conditionnelles permettent de faire des choix en fonction du contexte ou d’une saisie utilisateur.

Les boucles permettent de répéter des opérations jusqu’à obtenir un résultat satisfaisant ou d’énumérer un ensemble de choses afin d’effectuer un traitement (les compter, faire des additions, des multiplications, etc.).

Vous souhaitez poser une colle à votre utilisateur ? Attendre une réponse jusqu’à obtenir la bonne réponse à votre question ? Vous devez utiliser une boucle et une expression conditionnelle.

Voulez-vous organiser des choses ou rechercher un élément dans une liste ? Vous devez encore utiliser les boucles et les instructions conditionnelles.

C’est simple, elles sont partout en algorithmique !

 

Un code simple : le jeu de ping/pong

Imaginons un cas simple de répétition : nous jouons au ping-pong, tout seul, et nous devons afficher Ping et Pong alternativement.

Voici un exemple en pseudo-code :

Afficher("Ping");
Afficher("Pong");
Afficher("Ping");
Afficher("Pong");
Afficher("Ping");
Afficher("Pong");

 

Vous remarquez qu’il y a du code qui se répète.

Mieux, j’ai beau faire autant de copier-coller que je le souhaite, ce code va toujours se terminer à un moment précis, quand il n’y a plus d’instruction à exécuter.

Comment rendre ce code moins répétitif et augmenter facilement la durée d’exécution ?

 

Nous allons utiliser une boucle TantQue (While en anglais). Le code peut se réécrire ainsi :

TantQue(Vrai) faire
    Afficher("Ping");
    Afficher("Pong");
FinTantQue

 

Nous pourrions utiliser toutes les boucles pour réaliser ceci, même une boucle Pour (For en anglais) qui est plutôt dédiée aux tableaux. Mais je vous expliquerais plus tard que toutes les boucles, je dis bien TOUTES les boucles, sont interchangeables. J’ai déjà vu des développeurs se prendre la tête (et aussi, au passage, nous prendre la tête 😆 ) pour choisir une boucle plutôt qu’une autre. Elles sont toutes équivalentes ! Arrêtez de tergiverser et prenez-en une !

Je finirais avec une explication sur les différences et les liens entre les boucles ainsi qu’un guide pour savoir quelle boucle choisir.

 

OK, ce code n’est pas tout à fait équivalent, car dans un premier temps j’ai simplement fait une boucle sur la condition “vraie”. La boucle va donc continuer à tourner jusqu’à la fin des temps, ou plus exactement que vous arrêtiez violemment le programme. En effet, mettre TantQue(vrai), ou while(true) en anglais, créé une boucle infinie, qui va tourner éternellement.

Avant d’aller plus loin, étudions cette boucle plus en détail.

 

Comment fonctionne la boucle TantQue / While ?

Voici le fonctionnement de la boucle TantQue :

1. Quand le processeur arrive sur une boucle TantQue, il regarde l’expression qui est entre parenthèses.
2. Si cette expression est vraie :
   • Il va exécuter les instructions qui se trouvent dans le corps de la boucle, entre le faire et le FinTantQue (ou entre les { } dans la plupart des langages).
   • Quand il a fini d’exécuter toutes les instructions du corps de boucle, il retourne à l’étape 1)
3. Si cette expression est fausse, il saute le corps de la boucle et va directement exécuter les instructions qui se trouvent après.

 

Schématiquement, cela donne ceci :

 

Vous pouvez constater sur le schéma que la première fois, nous regardons la condition de boucle, qui est vraie.
Donc nous exécutons les deux lignes pour afficher Ping et Pong.
Ayant fini le corps de boucle, nous retournons tester la condition. Elle est toujours vraie, donc nous réexécutons le corps de boucle.
Et ainsi de suite éternellement, car la valeur de la condition ne changera jamais. Elle sera toujours vraie.

 

Une boucle qui se termine au 5e tour ?

Pour cela, il faut tout d’abord être capable de compter les tours. Comment faire ?
Arrêtez de lire. Prenez un stylo ou votre clavier, et imaginez comment modifier l’algorithme précédent pour compter les tours de boucle.
Vous avez un algo, ou a minima un début de solution ? Continuons.

Nous allons commencer par…

 

Calculer le numéro de tour

Comment le feriez-vous dans la vraie vie ? Comment comptez-vous ?
Par exemple, vous prenez votre main, et à chaque fois vous redressez un doigt.
Autre solution, vous prenez un tableau ou une feuille, et à chaque fois vous ajoutez un trait. Ne riez pas, nous le voyons tous à chaque élection…

 

En gros, nous prenons un contenant (main, tableau, feuille …) et nous modifions ce contenant pour garder l’information que nous souhaitons compte, en l’occurrence, « un tour de plus vient de passer ».
Pour cela, nous avons les variables. Ici nous devons compter des tours, c’est donc un chiffre entier, ce sera une variable de type entier. Et à chaque tour de boucle, il suffit que nous ajoutions la valeur 1 au contenu de cette variable.

 

Voici le nouveau programme :

Entier noTour;
noTour <- 1;
TantQue(Vrai) faire
    Afficher("Ping");
    Afficher("Pong");
    noTour <- noTour + 1;
    Afficher(noTour);
FinTantQue

 

J’ai un peu modifié l’algo pour calculer le numéro de tour et ensuite l’afficher.
Cela vous permet de bien voir ce qui se passe. C’est important pour bien comprendre, je vous recommande de toujours afficher l’état intermédiaire de vos variables. Lorsque cela sera devenu évident pour vous, vous pourrez enlever l’affichage.

 

Arrêt au 5e tour

Maintenant, il nous reste à nous arrêter quand noTour vaut 5.
Comment faire cela ?
Là aussi, arrêtez de lire et tentez de le faire par vous-même. Prenez 5 minutes pour essayer.

C’est bon ?
Alors on continue.

Vous vous rappelez la condition de boucle ?
Avec elle, nous pouvons indiquer au processeur quand arrêter de boucler. En effet, si cette condition est vraie, le processeur exécute le corps de la boucle. Cependant, si elle est fausse, le processeur va “sauter” le corps de la boucle et passer au code qui est juste après.

Quelle condition écrire qui soit fausse quand nous avons atteint le 5e tour de boucle ?
Tout simplement que noTour est différent de 5.
Nous pouvons l’écrire comme ceci :

    noTour!=5;

À savoir : “différent de” se note souvent !=

 

Le code complet modifié :

Entier noTour;
noTour <- 1;
TantQue(noTour!=5) faire
    Afficher("Ping");
    Afficher("Pong");
    noTour <- noTour + 1;
    Afficher(noTour);
FinTantQue

Tester sur la différence de 5 est tout de même un peu risqué. En effet, nous avons écrit que tant que noTour est différent de 5, nous pouvons exécuter le corps de boucle.
Cela fonctionne pour 1, 2, 3 et 4 mais aussi pour 6, 7, 8 etc.

Pour éviter tout risque, nous préférons souvent mettre la condition inférieure à 5. Nous obtenons le même résultat, la boucle tourne bien pour les tours 1, 2, 3 et 4 et s’arrête dès qu’elle est au 5e tour. Par contre, aucun risque si jamais noTour a une valeur supérieure à 5, et c’est même plus clair. Si c’est en dessous de 5, c’est une valeur attendue, nous tournons. Si c’est égal ou au-dessus de 5, nous sortons de la boucle.

 

Les autres types de boucles

Cet article est bien plus long que je ne l’imaginais, je vais donc traiter des autres types de boucles dans un prochain article.

Je rajouterais le lien ici dès qu’il est publié.

 

En conclusion

Nous avons découvert notre premier type de boucle : TantQue / While.
Vous avez vu que ce n’est pas très compliqué quand on décompose tout petit à petit.
C’est vrai de beaucoup de chose en informatique. C’est certainement la compétence la plus utile que vous devez acquérir : savoir bien décomposer un problème pour être capable de le résoudre.

 

Nous avons vu autre chose de très utile : le processeur suit strictement ce que nous lui demandons de faire. Le processeur est bête !
Gardez bien cela en tête. Un ordinateur n’est pas intelligent. Il est seulement capable de faire une suite d’opération bien plus vite que nous. Mais pour faire ces opérations, il suit un programme à la lettre. S’il ne fonctionne pas comme vous le vouliez, c’est que NOUS avons mis une erreur quelque part. Ne vous en prenez pas à l’ordinateur quand cela ne fonctionne pas, il n’y est pour rien lui (le pauvre 🙂). Il ne fait que suivre ce qu’on lui a demandé de faire, c’est tout !

 

Merci d’avoir lu cet article jusqu’au bout. J’espère qu’il vous a aidé à mieux comprendre l’intérêt des boucles en programmation. Si c’est le cas, n’hésitez pas à me le dire en commentaire, cela me fera plaisir. Vous pouvez également partager cet article avec vos amis, cela m’aide à faire connaître le site 😉.

Si vous voulez le code dans un langage particulier, dites-le-moi dans les commentaires.

 

À très bientôt.

 

Crédit photo