5. Les structures répétitives

Présentation au sujet: "5. Les structures répétitives"— Transcription de la présentation:

1 5. Les structures répétitives
P. Costamagna – ISEN N1

2 A. A quoi sert une boucle ? = structures itératives ou boucles.
2ème méthode permettant de rompre l’ordre séquentiel d’un programme. = structures itératives ou boucles. Les boucles permettent de faire exécuter plusieurs fois certaines phases de programme sans qu'il soit nécessaire à chaque fois de réécrire les instructions correspondantes. Il existe 3 types de boucles qu’il faut apprendre à choisir judicieusement. P. Costamagna

3 B. La boucle TANT QUE … Fonctionnement : Tant que booléen faire
Langage intermédiaire Fonctionnement : Tant que booléen faire instructions (1) ... Ftq instructions (2) … évaluation du booléen si sa valeur est vraie, alors le bloc instructions (1) est exécuté le booléen est à nouveau évalué si sa valeur ... arrêt de la boucle quand le booléen devient faux le programme continue en séquence avec les instructions(2). le booléen est évalué. C’ est le test de continuité (booléen vrai) ou test d'arrêt (booléen faux). Instructions (1) est appelé corps de la boucle P. Costamagna

4 B. La boucle TANT QUE … (suite1)
Remarques : Langage C Cette boucle peut ne jamais être parcourue si le booléen est faux dès le début. while (expression) { instructions (1) ... } instructions (2) … Inversement le nombre d’itérations peut être infini si le booléen reste toujours vrai. Il est possible d’imbriquer des boucles TANT QUE. Pas de ; à la fin de l’instruction while. P. Costamagna

5 B. La boucle TANT QUE … (suite2)
Exercice Ecrire en langage C largement commenté, un algorithme qui affiche la valeur inverse du code octal d’un entier positif. Exemple : 611 en base 10 devient 1 143 en base 8 En effet 611 = 3 x x x x 83 Notre algorithme affichera donc Pour obtenir ce résultat, on utilise la méthode des divisions successives par 8 : Chaque carré en pointillés représente une division par 8. Les restes successifs donnent le code octal de l’entier. Ce calcul ne sera effectué que dans le cas où le nombre à convertir est positif. P. Costamagna

6 B. La boucle TANT QUE … (suite3)
Correction #include "ESLib.h" int main () { int n; /* nombre a convertir */ int q; /* quotient de la division entiere */ int r; /* reste de la division entiere */ /* saisie du nombre a convertir */ ecrisChaine ("Saisir un entier positif "); n = lisEntier(); sautDeLigne(); P. Costamagna

7 B. La boucle TANT QUE … (suite4)
/* Conversion effectuee uniquement si le nbre saisi est positif */ if (n >0) { q = n; /* initialisation du 1er diviseur avec la valeur à convertir */ /* Arret des divisions successives des que le quotient devient nul */ while (q > 0) /* calcul du nouveau quotient */ q = n / 8; /* calcul du reste */ r = n % 8; /* affichage du résultat au fur et a mesure des divisions */ ecrisEntier(r); /* initialisation du nouveau diviseur a considerer */ n = q; } Initialisation de la variable q La variable q doit être déterminée en arrivant sur cette instruction La variable q doit être modifiée dans le corps de la boucle pour permettre une sortie de boucle P. Costamagna

8 B. La boucle TANT QUE … (suite5)
else ecrisChaine ("Conversion non prevue"); sautDeLigne(); system ("pause"); return 0; } P. Costamagna

9 C. La boucle REPETER … Fonctionnement : Répéter instructions (1) ...
Langage intermédiaire le bloc instructions (1) est exécuté une fois le booléen est évalué si sa valeur est vraie, le bloc d’instructions (1) est à nouveau exécuté le booléen est à nouveau évalué … arrêt de la boucle quand le booléen devient faux le programme continue en séquence avec les instructions(2). Répéter instructions (1) ... Tant que (booléen) instructions (2) … P. Costamagna

10 C. La boucle REPETER … (suite1)
Remarques : Langage C Cette boucle est toujours exécutée au moins une fois. do { instructions (1) ... } while (expression); instructions (2) … Le nombre d’itérations peut être infini si le booléen reste toujours vrai. Il est possible d’imbriquer des boucles REPETER. Pas de ; à la fin de l’instruction do mais un ; à la fin de l’instruction while. P. Costamagna

11 C. La boucle REPETER … (suite2)
Exercice Ecrire en langage C, un algorithme qui oblige un utilisateur à saisir la réponse O(ui) ou N(on)à une question. Correction #include "ESLib.h" int main () { char rep; /* caractere a saisir pour la reponse */ do ecrisChaine ("Voulez vous saisir qlqchose ? (O/N)" ); rep = lisCaractere(); } while (rep != 'O' && rep != 'N'); sautDeLigne(); system ("pause"); return 0; } Initialisation de la variable rep lors du 1er passage dans la boucle, puis modification de cette variable lors des passages suivants P. Costamagna

12 D. Notion de compteur de boucle
Les 2 structures de boucles étudiées (TANT QUE et REPETER, sont utilisées dans des situations où l’on ne sait pas par avance combien de tours seront nécessaires. Possibilité néanmoins de compter les tours de boucle effectués à l’aide d’une variable entière, initialisée à 0 et dont on augmente de un la valeur à chaque tour. C’est le compteur de boucle. Ce compteur peut alors servir à comptabiliser les passages dans la boucle (compteur passif) ou servir à limiter le nombre de tours de boucles (compteur actif) P. Costamagna

13 D. Notion de compteur de boucle (suite1)
Exercice A partir de l’exercice précédent, écrire en langage C, un algorithme qui affiche le nombre d’essais nécessaire à l’utilisateur pour effectuer la bonne saisie. do { ecrisChaine ("Voulez vous saisir qlqchose ? (O/N)" ); rep = lisCaractere(); /* incrémentation du nombre de passages */ cpt = cpt +1; } while (rep != 'O' && rep != 'N'); ecrisChaine ("Nombre d'essais = "); ecrisEntier (cpt); sautDeLigne(); system ("pause"); return 0; Correction #include "ESLib.h" int main () { char rep; /* caractere a saisir pour la reponse */ int cpt ; /* compteur de boucle */ /* initialisation du compteur de passages */ cpt = 0; P. Costamagna

14 D. Notion de compteur de boucle (suite2)
Exercice A partir de l’exercice précédent, écrire en langage C, un algorithme qui limite le nombre d’essais à 3 pour effectuer une saisie correcte. do { ecrisChaine ("Voulez vous saisir qlqchose ? (O/N)" ); rep = lisCaractere(); /* incrémentation du nombre de passages */ cpt = cpt +1; } while (rep != 'O' && rep != 'N' && cpt <3); if (cpt == 3) ecrisChaine ("Nombre d'essais depasse "); sautDeLigne(); system ("pause"); return 0; Correction #include "ESLib.h" int main () { char rep; /* caractere a saisir pour la reponse */ int cpt ; /* compteur de boucle */ /* initialisation du compteur de passages */ cpt = 0; P. Costamagna

15 E. La boucle POUR … Pour cpt = depart à arret pas val instructions (1)
Langage intermédiaire valeur initiale de la boucle variable correspondant au compteur de boucle. pas d’incrémentation de la boucle Pour cpt = depart à arret pas val instructions (1) Fpour instructions (2) … valeur de sortie de la boucle P. Costamagna

16 E. La boucle POUR … (suite1)
Fonctionnement : Lors du 1er passage, le compteur est initialisé avec la valeur de départ et est comparé avec la valeur d’arrêt Si départ <= arrêt alors le bloc instructions (1) est exécuté une fois Lors des passages suivants, le compteur est incrémenté à chaque nouveau passage de la valeur du pas Si la nouvelle valeur du compteur est <= arrêt, le bloc d’instructions (1) est à nouveau exécuté le compteur est à nouveau incrémenté … arrêt de la boucle quand le compteur devient > arrêt. le programme continue en séquence avec les instructions(2). Ce déroulement est donné pour un pas positif. Dans le cas d’un pas négatif, les comparaisons sont inversées. P. Costamagna

17 E. La boucle POUR … (suite2)
Remarques : Il est inutile d’initialiser le compteur de boucle avant la boucle POUR. La valeur du compteur ainsi que les valeurs de départ et d’arrêt de la boucle ne doivent pas être modifiées à l’intérieur de la boucle. depart et arret peuvent être des valeurs fixées ou des expressions. Cette structure de boucle est à privilégier dans les situations où l’on connaît d’avance le nombre de passages à effectuer dans la boucle. Cette structure de boucle n’est pas du tout indispensable. Son grand intérêt est d’épargner un peu de fatigue au programmeur, en lui évitant de gérer lui-même la progression du compteur de boucle. P. Costamagna

18 E. La boucle POUR … (suite3)
Langage C for (expr1 ; expr2 ; expr3) { instructions (1) ... } instructions (2) … expr1: initialisation du compteur de boucle expr2: test d’arrêt de la boucle expr3: incrémentation du compteur de boucle Exemple for (i=1 ; i <=8 ; i= i+2) ecrisEntier (i) Pas de ; à la fin de l’instruction. P. Costamagna

19 E. La boucle POUR … (suite4)
Exercice Ecrire en langage C, un algorithme qui affiche la table de multiplication de 1 à 10 d’un nombre choisi par l’utilisateur. for (cpt=1; cpt <=10; cpt = cpt+1) { ecrisEntier(cpt); ecrisChaine (" x "); ecrisEntier(n); ecrisChaine (" = "); ecrisEntier (n * cpt); sautDeLigne(); } system ("pause"); return 0; Correction #include "ESLib.h" int main () { int n; /* valeur de la table de multiplication */ int cpt; /* cpt de boucle pour les 10 multiplications */ ecrisChaine ("Saisir un nombre "); n = lisEntier(); sautDeLigne(); P. Costamagna

20 F. Choisir la bonne boucle
En réalité une seule boucle aurait pu suffire. Suivant la nature du pb à résoudre telle ou telle forme de boucle s’avérera plus adaptée en conduisant à des formulations plus simples. Questions à se poser Le nombre de tours de boucle est il connu ? OUI  utiliser la boucle POUR NON  Peut on commencer l'action avant de tester une situation? OUI  utiliser la boucle REPETER NON  utiliser la boucle TANT QUE P. Costamagna

21 G. Quelques erreurs à éviter
Le compteur de la boucle TANT QUE n’est pas initialisé: ….. i = 0; while( i < 10 ) { ecrisChaine ("hello world !"); i = i + 1; } ….. while( i < 10 ) { ecrisChaine ("hello world !"); i = i + 1; } Erreur dans la comparaison  la condition ne sera jamais vraie, donc la boucle ne sera pas exécutée : i = 0; while( i > 10 ) { ecrisChaine ("hello world !"); i = i + 1; } i = 0; while( i < 10 ) { ecrisChaine ("hello world !"); i = i + 1; } P. Costamagna

22 G. Quelques erreurs à éviter (suite1)
Le compteur de la boucle TANT QUE n’est pas incrémenté  boucle infinie: i = 0; while( i < 10 ) { ecrisChaine ("hello world !"); } i = 0; while( i < 10 ) { ecrisChaine ("hello world !"); i = i + 1; } Attention aux ; en trop. La boucle suivante ne fait rien pendant 10 fois puis affiche la phrase hello world ! une seule fois : for ( i = 0; i < 10; i = i+1 ); ecrisChaine ("hello world !"); for ( i = 0; i < 10; i = i+1 ) ecrisChaine ("hello world !"); P. Costamagna