5. Les structures répétitives P. Costamagna – ISEN N1.
-
Upload
salomon-piquet -
Category
Documents
-
view
105 -
download
0
Transcript of 5. Les structures répétitives P. Costamagna – ISEN N1.
5. Les structures répétitives5. Les structures répétitives
P. Costamagna – ISEN N1
P. Costamagna 2
A. A. A quoi sert une boucle ?A quoi sert une boucle ?
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 …B. La boucle TANT QUE …
Fonctionnement : é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).
Langage intermédiaireTant que booléen faire
instructions (1)
...
Ftq
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 … B. La boucle TANT QUE … (suite1)(suite1)
Remarques : Cette boucle peut ne jamais
être parcourue si le booléen
est faux dès le début.
Langage C
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 … B. La boucle TANT QUE … (suite2)(suite2)
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 80 + 4 x 81 + 1 x82 + 1 x 83
Notre algorithme affichera donc 3 411. 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.
Exercice
P. Costamagna 6
B. La boucle TANT QUE … B. La boucle TANT QUE … (suite3)(suite3)
#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();
Correction
P. Costamagna 7
B. La boucle TANT QUE … B. La boucle TANT QUE … (suite4)(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; } }
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
Initialisation de la variable q
P. Costamagna 8
B. La boucle TANT QUE … B. La boucle TANT QUE … (suite5)(suite5)
else
ecrisChaine ("Conversion non prevue");
sautDeLigne();
system ("pause");
return 0;
}
P. Costamagna 9
C. La boucle REPETER …C. La boucle REPETER …
Fonctionnement : 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).
Langage intermédiaire
Répéter
instructions (1)
...
Tant que (booléen)
instructions (2) …
P. Costamagna 10
C. La boucle REPETER … C. La boucle REPETER … (suite1)(suite1)
Remarques : Cette boucle est toujours
exécutée au moins une fois.
Langage C
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 … C. La boucle REPETER … (suite2)(suite2)
Ecrire en langage C, un algorithme qui oblige un utilisateur à saisir la réponse O(ui) ou N(on)à une question.
Exercice
#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');
Correction 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 boucleD. 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 D. Notion de compteur de boucle (suite1)(suite1)
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.
Exercice
#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;
Correction
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;}
P. Costamagna 14
D. Notion de compteur de boucle D. Notion de compteur de boucle (suite2)(suite2)
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.
Exercice
#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;
Correction
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;}
P. Costamagna 15
E. La boucle POUR …E. La boucle POUR …
Langage intermédiaire
Pour cpt = depart à arret pas val
instructions (1)
Fpour
instructions (2) …
variable correspondant au compteur de boucle.
valeur initiale de la boucle
valeur de sortie de la boucle
pas d’incrémentation de la boucle
P. Costamagna 16
E. La boucle POUR … E. La boucle POUR … (suite1)(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 … E. La boucle POUR … (suite2)(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 … E. La boucle POUR … (suite3)(suite3)
for (i=1 ; i <=8 ; i= i+2)
ecrisEntier (i)
Langage C
for (expr1 ; expr2 ; expr3)
{ instructions (1)
...
}
instructions (2) …
Pas de ; à la fin de l’instruction.
expr1: initialisation du compteur de boucle
expr2: test d’arrêt de la boucle
expr3: incrémentation du compteur de boucle
Exemple
P. Costamagna 19
E. La boucle POUR … E. La boucle POUR … (suite4)(suite4)
Ecrire en langage C, un algorithme qui affiche la table de multiplication de 1 à 10 d’un nombre choisi par l’utilisateur.
Exercice
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();
for (cpt=1; cpt <=10; cpt = cpt+1) { ecrisEntier(cpt); ecrisChaine (" x "); ecrisEntier(n); ecrisChaine (" = "); ecrisEntier (n * cpt); sautDeLigne(); } sautDeLigne(); system ("pause"); return 0;}
P. Costamagna 20
F. Choisir la bonne boucleF. 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 POURNON Peut on commencer l'action avant de tester une situation? OUI utiliser la boucle REPETERNON utiliser la boucle TANT QUE
P. Costamagna 21
G. Quelques erreurs à éviterG. Quelques erreurs à éviter
…..while( i < 10 ){ ecrisChaine ("hello world !"); i = i + 1;}
Le compteur de la boucle TANT QUE n’est pas initialisé:
…..i = 0;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 G. Quelques erreurs à éviter (suite1)(suite1)
i = 0;while( i < 10 ){ ecrisChaine ("hello world !");}
Le compteur de la boucle TANT QUE n’est pas incrémenté boucle infinie:
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 !");