Chapitre 3 Les structures de contrôle: approfondissements

Chapitre 3 Les structures de contrôle: approfondissements Nous allons reprendre dans ce chapitre, l'étude des structures de contrôle. Dans un premier temps, nous étudierons d'autres structures que celles que l'on a étudié jusqu'à présent. Ensuite, nous verrons comment on peut imbriquer les structures de contrôle et par la même occasion, nous étudierons la programmation descendante. I. Les différentes structures de contrôle A. Un extension de la structure Si: La structure SelonFaire (de choix) La structure Selon permet de choisir le traitement à effectuer en fonction de la valeur ou de l'intervalle de valeur d'une variable ou d'une expression. Cette structure permet de remplacer avantageusement une succession de structures SiAlors. La syntaxe de cette structure est Selon expression Faire valeur 1 de l'expression : traitement 1 valeur 2 de l'expression : traitement 2 valeur 3 de l'expression : traitement 3 [Sinon traitement par défaut] selon Exemple1: Les différents cas sont des valeurs littérales. Voilà l'algorithme qui affiche le mois en toute lettre selon son numéro. Le numéro du mois en mémorisé dans la variable mois. Selon mois Faire 1 : Afficher "Janvier" 2 : Afficher "Février" 3 : Afficher "Mars" 4 : Afficher "Avril" 11: Afficher "Novembre" 12: Afficher "Décembre" Sinon Afficher "Un numéro de mois doit être compris entre 1 et 12" selon 1

Exemple 2: Les différents cas possibles sont décrits par des intervalles de valeur (taux de remise différent selon le montant d'achat) Selon montant Faire <1000 : taux! 1 1000 et < 3000: taux! 2 3000 et < 10000: taux! 3 10000: taux! 4 Selon montant! montant * ( 1 taux/100) B. La boucle Jusqu'à Cette boucle sert à répéter une instruction jusqu'à ce qu'une condition (expression booléenne) soit vraie. Son formalisme est le suivant: traitement // une instruction simple ou un bloc d'instructions Jusqu'à condition d'arrêt Le traitement est exécuté, puis la condition est vérifiée. Si elle n'est pas vraie, on retourne au début de la boucle et le traitement est répété. Si la condition est vraie, on sort de la boucle et le programme continue séquentiellement. A chaque fois que le traitement est exécuté, la condition d'arrêt est de nouveau vérifiée à la fin. " Exemple: Programme Aire rayon : réel réponse : chaîne Afficher "Calcul de l'aire d'un cercle" Afficher "Entrez le rayon d'un cercle en cm" Saisir rayon Afficher "L'aire de ce cercle est ", rayon*rayon *3.14, "cm²" Afficher "Voulez-vous l'aire d'un autre cercle? (oui/non)" Saisir réponse Jusqu'à réponse "oui" //si la réponse est différente de "oui", la répétition du traitement s'arrête Afficher "Au revoir!" La boucle n'est pas indispensable. Elle peut toujours être remplacée par une boucle Tantque. C'est pourquoi certains langages n'ont pas d'équivalent pour la boucle. 2

Différences entre la boucle et Tantque Tant quefaire Condition vérifiée avant le traitement: le traitement peut ne pas être exécuté condition de continuation : le traitement est répété si la condition est vraie Jusqu'à Condition vérifiée après le traitement: le traitement est forcément exécuté une fois condition d'arrêt : le traitement est répété si la condition est fausse Faux test Vrai traitement traitement test Faux suite Vrai suite II. L'imbrication des Structures Si Les structures conditionnelles peuvent être imbriquées (c'est-à-dire incluses les unes dans les autres). Voilà un programme qui fait la même chose que l'exemple 2 sur la structure Selon, mais utilisant l'imbrication des structures Si. Programme taux montant, taux: entiers Si montant < 1000 //(1) Alors taux! 1 Sinon Si montant < 3000 //(2) Alors taux! 2 Sinon Si montant < 10000 //(3) Alors taux! 3 Sinon taux!4 si //(3) si //(2) si //(1) Montant! montant - montant * taux/100 Afficher montant Si le montant est inférieur à 1000, la valeur 1 est affectée au taux et le programme passe à l'instruction suivante. Attention, l'instruction suivante n'est pas celle qui suit Sinon. 3

Si la condition est vérifiée, tout ce qui suit le Sinon est ignoré, y compris les Si qui sont imbriqués dans le Sinon. Donc le programme passe à l'instruction suivante qui est montant! montant - montant * taux/100 En ce qui concerne la présentation, nous avons décalé vers la gauche les structures imbriquées. C'est une convention d'écriture qu'on retrouve pour toutes les structures, et qui a pour but de rendre l'algorithme plus lisible. #Les structures imbriquées sont emboîtées telles des poupées russes. Il est impossible qu'elles se chevauchent. Cela est valable pour les structures conditionnelles et pour toutes les autres structures. Dans ce cas, le premier Si rencontré dans l'algorithme indique toujours la fin de la structure la plus imbriquée. Il est donc inutile de numéroter les structures pour reconnaître où elles se terminent. Représentation schématique: La plupart du temps, la structure Selon va permettre d'éviter l'imbrication des structures Si. Pourtant, il est indispensable de savoir les utiliser pour deux raisons: - dans le langages C++ et dans d'autres langages, la Structure équivalente à Selon ne permet pas d'utiliser des intervalles de valeur (voir le cours de C++). - il est parfois impossible d'utiliser la structure Selon, en particulier lorsque les conditions portent sur plusieurs variables. III. L'imbrication des boucles Comme les structures conditionnelles, les boucles peuvent être imbriquées. Cette partie n'apporte pas de notion nouvelle mais permet de souligner certains aspects délicats. Le morceau d'algorithme suivant permet simplement d'afficher 5 étoiles. Il n'y a pas d'imbrication pour l'instant. Pour i de 1 jusqu'à 5 Faire Afficher "*" 4

Si on inclut cette séquence à l'intérieur d'une boucle qui se répète 3 fois, on va effectuer 3 fois l'affichage de 5 étoiles donc on va obtenir l'affichage de 15 étoiles. $ L'imbrication des boucles multiplie les tours de boucles Pour j de 1 jusqu'à 3 Faire Pour i de 1 jusqu'à 5 Faire Afficher "*" * * * * * * * * * * * * * * * # Remarque TRES importante: Lorsque l'on imbrique des boucles, IL FAUT UTILISER DES COMPTEURS DIFFERENTS pour chaque boucle. Pour pouvoir afficher 3 lignes de 5 étoiles, au lieu de 15 étoiles à la suite, il suffit d'ajouter un saut de ligne après le Pour le plus imbriqué. ***** ***** ***** Pour j de 1 jusqu'à 3 Faire Pour i de 1 jusqu'à 5 Faire Afficher "*" Afficher "\n" La boucle la plus imbriquée s'exécute alors que la "grande" boucle s'exécute seulement 3 fois. Le compteur i varie 5 fois plus vite que le compteur j. Trace j = 1 j = 2 j = 3 i = 1 i = 2 i = 3 i = 4 i = 5 i = 1 i = 2 i = 3 i = 4 i = 5 i = 1 i = 2 i = 3 i = 4 i = 5 * * * * * * * * * * * * * * * saut de ligne saut de ligne saut de ligne Tous les types de boucles peuvent s'imbriquer entre eux. La seule règle à respecter est que les boucles ne doivent pas se chevaucher: elles doivent s'emboîter. Si vous respectez bien la règle des décalages, vous ne pouvez pas vous tromper. OK Tantque a > b Faire Pour i de 1 jusqu'à n Faire Tantque IMPOSSIBLE Tantque a > b Faire Pour i de 1 jusqu'à n Faire Tantque 5

" Exemple d'imbrication de boucles différentes Voilà un programme qui calcule le chiffre d'affaire annuel d'un représentant à partir de la saisie des 12 chiffres d'affaire mensuels. Le programme permet de recommencer le calcul avec un autre représentant si l'utilisateur tape le caractère 'o' (pour oui). Programme CA CAM : réel CAA : réel mois : entier réponse : caractère //chiffre d'affaire mensuel //chiffre d'affaire annuel //compteur de la boucle qui calcule le CA annuel Afficher "Veuillez entrer les 12 chiffres d'affaire mensuels d'un représentant" CAA! 0 //réinitialisation du CA annuel pour chaque représentant. Pour mois de 1 jusqu'à 12 Faire Saisir CAM CAA! CAA + CAM //cumul Afficher "Chiffre d'affaire annuel :", CAA Afficher "Voulez-vous calculer le chiffre d'affaire annuel d'un autre représentant?" Saisir réponse Jusqu'à réponse 'o' L'imbrication des boucles n'est pas compliquée si on pense à bien décomposer les problèmes, du général au particulier (c'est l'approche descendante). Pour cela, il faut procéder à une analyse du problème sans rentrer dans les détails de l'algorithme. On réfléchit d'abord à QUOI faire avant de réfléchir à COMMENT faire. Le quoi faire de l'algorithme précédent pourrait s'exprimer ainsi. calculer le chiffre d'affaire d'un représentant et l'afficher demander à l'utilisateur s'il veut continuer Jusqu'à ce qu'il ne réponde pas 'o' (recommencer tant qu'il répond 'o') A l'issue de cette étape d'analyse, on réfléchit au COMMENT. On se rend compte alors que pour calculer le chiffre d'affaire d'un représentant, il faut utiliser une boucle Pour. Cette boucle vient donc naturellement s'imbriquer dans la boucle. % Application de la démarche descendante : les tables de multiplication On veut écrire un algorithme qui calcule et affiche les 10 tables de multiplication (de 1 à 10). Chaque table doit être présentée comme exemple de la table du 7 ci-dessous: La table du 7 est: 1 * 7 = 7 2 * 7 = 14 3 * 7 = 21 4 * 7 = 28 5 * 7 = 35 6

6 * 7 = 42 7 * 7 = 49 8 * 7 = 56 9 * 7 = 63 10 * 7 = 70 Plutôt que d'essayer d'écrire immédiatement l'algorithme complet, il est préférable de faire une approche descendante du problème. Cela consiste à décomposer le problème en sous-problèmes plus simples à résoudre. Si certains sous-problèmes sont décomposables en problèmes plus petits, on les décompose encore. Ensuite, chaque sousproblème est résolu séparément et enfin, ils sont ré-assemblés pour composer la solution complète. Dans notre problème, nous constatons qu'il s'agit d'afficher 10 tables de multiplication, le numéro de la table augmentant d'un à chaque fois: on va donc utiliser une boucle Pour. Pour n de 1 jusqu'à 10 Faire afficher la table numéro n Le traitement décrit en italique doit être précisé. Pour écrire la table des n, on affiche d'abord le libellé, puis on utilise une boucle pour chaque nombre de 1 à 10. # ATTENTION : n est le numéro de la table, donc on ne peut pas l'utiliser comme compteur dans la boucle des 10 nombres. On va plutôt utiliser l comme ligne Afficher "La table du", n, "est :" Pour l de 1 jusqu'à 10 Faire Afficher la ligne l de la table n Le traitement décrit en italique doit encore être précisé. Pour afficher une ligne, il suffit d'utiliser l'instruction: Afficher l, " * ", n, " = ", l *n On va maintenant recomposer le programme entier en ajoutant les déclarations habituelles: Programme tables n: entier //numéro de la table l : entier // ligne de la table Pour n de 1 jusqu'à 10 Faire Afficher "La table du", n, "est :" Pour l de 1 jusqu'à 10 Faire Afficher l, " * ", n, " = ", l *n 7

TANT QUE TANT QUE <condition d'exécution> FAIRE <traitement (corps de la boucle)> FINTANTQUE &'Le corps de la boucle n'est exécuté que si la condition est vraie. Il peut ne jamais être exécuté. &'La valeur de l'expression évaluée dans la condition d'exécution doit devenir fausse pour sortir de la boucle. REPETER REPETER <traitement (corps de la boucle)> JUSQU'A <condition d'arrêt> &'Le corps de la boucle est exécuté au moins une fois &'La valeur de l'expression évaluée dans la condition d'exécution doit devenir vraie pour sortir de la boucle. POUR POUR <variable> DE <valeur intiale> JUSQU'A <valeur finale> PAS DE <incrément> FAIRE FINPOUR <traitement (corps de la boucle)> &'Le nombre de fois où la boucle sera exécuté est connu d'avance &'<variable> est augmentée de l'incrément à chaque tour de boucle Programme exemple n, cpt :entiers /* n est la valeur pour laquelle la boucle doit s'arrêter et cpt est le compteur*/ /*initialisations*/ Saisir n cpt! 1 /* boucle*/ Tantque cpt <= n Faire Afficher cpt cpt! cpt + 1 tantque Programme exemple n, cpt :entier /* n est la valeur pour laquelle la boucle doit s'arrêter et cpt est le compteur*/ /* initialisations*/ Saisir n cpt! 0 /*boucle*/ cpt! cpt + 1 Afficher cpt Jusqu'à cpt = n Programme exemple n, cpt :entiers /* n est la valeur pour laquelle la boucle doit s'arrêter et cpt est le compteur*/ /* initialisations*/ Saisir n /*boucle*/ Pour cpt de 1 jqà n Faire Afficher cpt pour 8