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)

...

}


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


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


#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


/* 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


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)


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


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


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


for (i=1 ; i <=8 ; i= i+2)

ecrisEntier (i)

Langage C

for (expr1 ; expr2 ; expr3)

{ instructions (1)

...

}


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


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 !");

Documents

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