isbn 0-321-49362-1 chapitre 8 structure de contrôle

ISBN 0-321-49362-1

Chapitre 8

Structure de contrôle

1-2

Chapitre 8: Sujets

• Introduction• Instructions de sélections• Instructions d'itérations• Branchements inconditionnels• Branchements conditionnels• Conclusions

1-3

Niveaux de flot de contrôle

– Dans les expressions (chapitre 7)– Entre les différentes unités du

programme (chapitres 9 et 10)– Entre les instructions

1-4

Instructions de contrôle: Évolution

• Années 50:– FORTRAN I: Directement liées à l'architecture du IBM

704– if et goto

• Années 60:– Résultat important: Il est prouvé que tout algorithme

exprimé par un organigramme peut être encodé dans un langage possédant seulement 2 instructions de contrôle:1. instruction pour choisir entre deux flots de contrôle2. instruction pour le contrôle logique d'un processus

itératif– Conclusion: Le goto est utile mais non essentiel– La lisibilité et la facilité d'écriture impose l'utilisation de

plus de 2 instructions de contrôle

1-5

Structure de contrôle

• Une structure de contrôle est une instruction controlant l'exécution d'un groupe d'instructions

• Choix de conception – Une structure de contrôle devrait-elle avoir

plusieurs points d'entrées?• Possible en présence de goto et d'étiquettes

d'instructions.– Points de sorties?

• Pas de problème si l'instruction de sortie est fixe– Exemple: Utilisation du break dans un switch en C

• Sinon, la situation est équivalente à utiliser un goto

1-6

Instructions de sélection

• Une instruction de sélection permet de choisir entre deux ou plusieurs flots

• Deux catégories générales:– Deux choix– Plusieurs choix

1-7

Instruction de sélection à deux choix

• Forme générale:if expression_controle

then clauseelse clause

• Choix de conception:– Quel est la forme et le type de l'expression

de contrôle? – Comment les clauses then et else sont-elles

spécifiées?– Comment spécifier la sémantique des

sélecteurs imbriqués?

1-8

Sélection à un seul choix:Exemples• FORTRAN: IF (expr_booleenne) énoncé• Problème: On ne peut choisir qu'un seul énoncé;

pour en choisir plus, on doit utiliser un goto IF (.NOT. condition) GOTO 20

...

GOTO 30

20 CONTINUE

...

30 ...

• L'utilisation de négations nuit à la lisibilité• Ce problème fut résolu dans FORTRAN 77

1-9

Sélection à deux choix: Exemples

• ALGOL 60: if (boolean_expr) then instruction)

else instruction• Les instructions peuvent être simples ou

composées.

1-10

Sélecteurs imbriqués

• Java: exemple if (sum == 0)

if (count == 0) result = 0; else result = 1;

• À quel if appartient le else? • La sémantique en Java est la suivante:

– le else correspond au if le plus près

• Note: Il s'agit du problème d'ambiguïté rencontré avec les grammaires hors-contextes.

1-11

Sélecteurs imbriqués (suite)

• Pour forcer une sémantique alternative, on doit utiliser les instructions composées:

if (sum == 0) { if (count == 0) result = 0;

} else result = 1;• Cette solution est utilisée en C, C++, JavaScript, PHP et

C#• En Perl elles sont toujours composées• La fin du if peut aussi être indiquée par un mot réservé:

– end if en Ada– End If en Fortran et Visual basic– end en Ruby et Lua– Indentation en Python

1-12

Sélections multiples

• On choisit parmi un nombre arbitraire d'instructions

• Choix de conception:1. Quel est la forme et le type de l'expresion de contrôle? 2. Comment spécifier les différentes sélections?

– Une sélection est un des segment de code faisant l'objet de la sélection

3. Le flot de contrôle est-il restreint à une seule sélection?

4. Que fait-on avec les expressions non représentées par l'ensemble des sélection possibles?

1-13

Sélections multiples: Exemple

• Sélecteur multiple:– FORTRAN: arithmetic IF (sélecteur à 3 choix)

IF (expression arithmetique) N1, N2, N3– N1, N2 et N3 sont des étiquettes– Le flot de contrôle va à:

• N1 si <0• N2 si =0• N3 si >0

1-14

Sélections multiples: Exemples

• Sélections multiples modernes:– L'instruction switch en C

switch (expression) {

case const_expr_1: stmt_1;

…

case const_expr_n: stmt_n;

[default: stmt_{n+1}]

}

1-15


• Choix de conception pour le switch:1. L'expression de contrôle doit être un type

entier2. Plusieurs sélections peuvent être

exécutées (il n'y a pas de branchement implicite à la fin d'une sélection)

3. la clause default sert à représenter les choix manquants (en l'absence de default, ces choix sont ignorés)

1-16


• L'instruction switch en C#:– Comme en C sauf que l'on est obligé de

mettre un break (ou un goto) après chaque sélection.

1-17


• L'instruction case en Adacase expression is

when liste de choix => instructions;…when liste de choix => instructions;[when others => instructions;]

end case;• Liste de choix: 10..15 ou 10|15|20• Les listes de choix doivent être exhautives• Les listes de choix doivent être disjointes• Sortie implicite après toutes les listes d'instructions• Plus fiable que le switch du C

1-18


• L'instruction case en Ruby (1ière forme):

bisextile = case

when annee%400==0 then true

when annee%100==0 then false

else annee%4==0

end

1-19


• L'instruction case en Ruby (2ième forme):

case expression

when valeur then instructions

when valeur then instructions

[else instructions]

end

1-20

Sélections multiples: avec le if

• Exemple en Ada:

if ... then ...elsif ... then ...elsif ... then ...else ...end if

1-21

Les instructions d'itération

• L'exécution répétée d'instructions est accomplie par la récursion ou par itération.

• Choix de conception générale:1. Comment contrôler un processus itératif? 2. Où placer le mécanisme de contrôle?

1-22

Boucles à compteur

• La boucle est contrôlée par un compteur • Les paramètres de la boucle sont:

– La valeur initiale du compteur– La valeur finale du compteur– L'incrément du compteur

1-23

Boucles à compteur (suite)

• Choix de conception:1. Quel est le type et la portée du compteur?2. Quelle est la valeur du compteur au sortir de

la boucle? 3. Peut-on changer la valeur du compteur et les

paramètres de la boucle à l'intérieur du corps de la boucle? Si oui, comment cela affecte-t-il le contrôle de la boucle?

4. Les paramètres de la boucle doivent-ils être évalués une seule fois ou avant chaque itération?

1-24

Instructions d'itération: Exemples

• Syntaxe du FORTRAN 90 DO étiquette var = début, fin [, increment]• L'incrément est n'importe quelle valeur

sauf 0 (la valeur de défaut est 1)• Les paramètres peuvent être des

expressions• Exemple:

Do 10 Index = 1, 100 ...

10 Continue

1-25


• Choix de conception:1. Le compteur doit être de type INTEGER2. Au sortir de la boucle, le compteur conserve

la dernière valeur qui lui a été affectée.3. Le compteur ne peut pas être modifié à

l'intérieur du corps de la boucle. 4. Les paramètres peuvent être changés sans

affecter le contrôle der la boucle (ils sont évalués une seule fois)

1-26


• Autre forme du DO en FORTRAN 95 :

[nom:] DO var = initial, terminal [,incrément]

...

END DO [nom]

– Le compteur doit être de type INTEGER

1-27


• L'instruction for en Pascalfor variable := initial (to|downto) final do

instruction

• Choix de conception:1. Le compteur doit être de type ordinal2. Au sortir de la boucle, la valeur du compteur est

indéfinie3. Le compteur ne peut pas être modifié dans la boucle. 4. Les paramètres sont évalués juste une fois: il peuvent

donc être changés sans affecter le contrôle

1-28


• Adafor var in [reverse] intervalle loop ...end loop

• intervalle d'entiers (1..n) ou enumération (lundi.. vendredi)

• Le compteur est déclaré implicitement et ne peut être modifié.

• Les paramètres sont évalué juste une fois.• La portée et la duré de vie du compteur se

limite à la boucle.

1-29


• L'instruction for en Cfor ([expr_1] ; [expr_2] ; [expr_3]) instruction

• N'importe quel type d'expressions est permis. En particulier on peut utiliser une séquence d'expressions séparées par des virgules. – La valeur de expr1, expr2, ..., exprn est exprn

• Il n'y a pas nécessairement de compteur explicite– for (nbcar=0; getchar()!=EOF; nbcar++);

• Tous les paramètres peuvent être changés dans la boucle

• La première expression est évaluée une seule fois, les autres à chaque itération.

1-30


• C++ diffère du C de deux façons:1. L'expression de contrôle peut être booléenne2. L'expression initiale peut contenir des

définitions (la portée est limitée à la boucle)

• Java et C#– L'expression de contrôle doit être booléenne.

1-31


• Python:for <variable> in <objet>:

<corps de la boucle>[else

<code de fin de boucle> ]• Exemple 1:

for X in [2, 4, 6]:print X

• Exemple 2for Y in range(2,100,2):

print Y

1-32

Boucles contrôlée logiquement

• La boucle est contrôlée par une expression logique

• Choix de conception:– Pré-test ou post-test?– Est-ce que ce type de boucle est une forme

particulière des boucles à compteur ou une instruction séparée?

• Formes générales en C et C++:

while (expr_logique) do

instruction instruction

while (expr_logique)

1-33

Boucles contrôlée logiquementExemple

• Pascal utilise deux formes distinctes de boucles (while-do et repeat-until)

• Java est comme le C, sauf que l'expresison de contrôle doit être de type booléen

• De plus, en Java, on ne peut entrer dans le corps d'une boucle que par le début car Java n'a pas d'instruction goto.

1-34

Boucles contrôlée logiquementExemple

• Ada possèdent une version pré-test mais aucune post-test

• FORTRAN 77 et 90 n'ont aucune des deux versions

• Perl possède deux boucles pré-test, while et until, mais aucune post-test

• Python possède une version pré-test (while)

1-35

Boucle avec contrôle de sortie placé par l'usager

• Il est quelque fois utile de pouvoir contrôler une boucle ailleurs qu'au début ou à la fin

• Conception simple pour les boucles simples (e.g., break)

• Choix de conception pour les boucles imbriquées:– Peut-on sortir de plus d'une boucle à la fois?

1-36

break et continue

• C , C++, Python, Ruby et Java: instruction break • Fonctionne dans n'importe quelle boucle ou

switch (un seul niveau) • Java et C# possèdent une instruction

break <etiquette>qui transfère le contrôle après la boucle portant l'étiquette.

• Perl: instruction last équivalente à break dans Java

• Alternative: instruction continue; saute par dessus le reste du code mais ne quitte pas la boucle.

1-37

Exemple en Java

Le code suivant fait la somme des éléments d'une matrice et arrête aussitôt que cette somme dépasse 1000.

Debut:for (i=0; i<nblignes; i++)

for (j=0; j<nbcol; j++){ somme += MAT[i][j]

if (somme > 1000.0)break Debut;

}

1-38

Exemple en Ada

Ada possède un mécanisme similaire:

NOM: loop énoncés exit NOM when condition end loop

1-39

Itérations et structures de données

• Le nombre d'éléments dans une structure de données contrôle le nombre d'itérations

• Le mécanisme de contrôle est aussi appelé itérateur. Un itérateur est une fonction permetant d'obtenir le prochain élément, s'il existe, sinon la boucle se termine.

• Un itérateur peut être construit en C: for (p=root; p==NULL; traverse(p)){...}

• L'utilisation des itérateurs est courante dans les langages orienté-objet tels que C++ et Java

1-40


• PHP: Les itérateurs sur les tableaux sont prédéfinis:

reset $listprint(current($list) + "<br />");while ($valeur = next($list))

print($valeur + "<br />");

1-41


• L'instruction foreach de C# permet d'itérer sur les éléments d'un tableau ou autres collections:

Strings[] Liste = {“Bob”, “Carol”, “Ted”};

foreach (Strings nom in Liste)

Console.WriteLine (“Nom: {0}”, nom);

• La notation {0} indique la position du paramètre (nom) que l'on veut afficher

1-42

Branchement inconditionnel

• Tranfère le contrôle à un emplacement quelconque du programme.

• Sujet d'un des plus vigoureux débats des années 60 et 70

• Puissant et flexible• Principal problème: Lisibilité• Certains langages ne supportent pas le goto (e.g., Modula-2 et Java)

• Les instructions tels que break et continue sont des formes restreintes de goto.

1-43

Branchement inconditionnel

• C# possède une instruction goto qui est principalement utilisée avec le switch:

switch (valeur){case -1:

negatif++;break;

case 0:zero++;goto case 1;

case 1:positif++break;

default:Console.WriteLine("Error dans le switch \n");break;

}

isbn 0-321-49362-1 chapitre 8 structure de contrôle

Documents