Nos connaissances actuelles ne nous permettent pas de faire des programmes utilisant la capacite de l'ordinateur de repeter rapidement et sans erreur beaucoup de calculs. Nous allons donc remedier immediatement a cela. Chaque structure de controle forme une instruction (qui peut donc etre utilisee dans une autre structure de controle).
structure : WHILE expression booleenne DO instruction
elle permet de repeter l'instruction tant que l'expression (ou la variable) booleenne est vraie.
ex : PROGRAM racine_a_deux_decimales(input,output);
VAR nombre,racine:REAL;
begin
writeln('entrez un reel entre 0 et 10');
readln(nombre);
racine:=0;
WHILE racine*racine < nombre DO racine:=racine+0.01;
writeln('la racine de ',nombre,' vaut a peu pres',racine)
END.
Il faut noter que si l'expression booleenne est fausse
des le debut, l'instruction n'est jamais executee
(ici si NOMBRE=0). Attention, Pascal n'initialise pas automatiquement les
variables a 0, c'est a dire que sans l'instruction RACINE:=0 le
programme risquerait de donner une reponse fausse (RACINE valant
n'importe quoi, il sera en general tres superieur
a la racine cherchee).On ne peut repeter qu'UNE seule instruction. Mais celle-ci peut etre simple (comme dans l'exemple precedent) ou composee (begin - end).
EXERCICE (ex_puiss) faire un programme qui affiche les puissances de 2 jusqu'a une valeur maxi donnee par l'utilisateur (par multiplication successive par 2).
structure : REPEAT instruction1; instruction2; ...etc... instructionN UNTIL conditionLes N instructions sont repetees jusqu'a ce que la condition soit verifiee. Meme si la condition est vraie des le debut, elles sont au moins executees une fois.
ex: PROGRAM jeu_simpliste(input,output);
VAR a:integer;
begin
writeln('entrez le nombre 482');
REPEAT
readln(a)
UNTIL a=482;
writeln('c''est gentil de m''avoir obei')
end.
Quelle que soit la valeur initiale de A (meme 482), la question sera au
moins posee une fois (plus si vous desobeissez).EXERCICE (ex_jeu) Faites un jeu qui demande de trouver le nombre entre 0 et 10 choisi par l'ordinateur (en comptant les coups). On utilisera la fonction RANDOM(N) (non standard, disponible en TURBO PASCAL) qui renvoie un entier entre 0 et N-1 compris, par l'instruction VALEUR_CHOISIE:=RANDOM(11).
structure :
FOR variable_enumeree:=valeur_debut TO valeur_fin DO instruction
La variable_enumeree (non reelle) prend la valeur_debut, et l'instruction est executee. Puis elle est incrementee (on passe a la suivante, c.a.d si elle est entiere on ajoute 1), et ce jusqu'a valeur_fin (compris).
L'instruction sera donc executee (valeur_fin - valeur_debut + 1) fois. Si valeur_ fin est inferieur a valeur_debut l'instruction n'est jamais executee. Cette forme de boucle est utilisee chaque fois que l'on connait le nombre de boucles a effectuer.
On peut utiliser un pas degressif en remplacant TO par DOWNTO.
ex: for lettre:='Z' downto 'A' do writeln(lettre)
ecrit l'alphabet a l'envers(en declarant LETTRE du type CHAR)
La variable_enumeree peut etre utilisee (mais pas modifiee) dans l'instruction (simple ou composee). Elle est souvent appelee "indice" de la boucle. Sa valeur est perdue des que l'on sort de la boucle.
EXERCICE (ex_moy) Faire un programme qui calcule la moyenne de N nombres. N doit etre demande par un READLN. (initialiser une variable a 0, y ajouter progressivement chaque note puis diviser par N).
structure : IF condition THEN instruction1 (CAS 1)
ou : IF condition THEN instruction1 ELSE instruction2 (CAS 2)
Si la condition est vraie, alors on execute l'instruction1 (simple ou composee). Sinon, on passe a la suite (cas 1), ou on execute l'instruction2 (cas 2).
Remarquez qu'il n'y a pas de ; devant le ELSE.
EXERCICE (ex_jeu_bis) modifier le jeu precedent (ex_jeu) en aidant le joueur (en precisant si c'est plus ou c'est moins).
L'instruction2 peut etre composee ou entre autres etre une instruction IF :
IF condition1 THEN instruction1 ELSE IF condition2 THEN instruction2 ELSE IF condition3 THEN instruction3 ...... ELSE instructionNUn ELSE correspond toujours au dernier IF rencontre (mais dont on n'a pas encore utilise le ELSE).
ex: IF cond1 then if cond2 then inst1 {cond1 et cond2}
else inst2 {cond1 et pas cond2}
else if cond3 then inst3 {pas cond1 mais cond3}
else inst4 {ni cond1 ni cond3}
Si on desire autre chose, utiliser BEGIN et END :IF cond1 THEN begin if cond2 then inst1 end (* le prochain ELSE se rapporte a COND1 puisque l'instruction (composee) suivant THEN est terminee *) ELSE inst2
Elle evite d'utiliser une trop grande suite de ELSE IF.
structure : CASE expression OF {regardez bien ou j'ai mis les ;}
liste_de_cas1:instruction1;
liste_de_cas2:instruction2;
.....
liste_de_casN:instructionN
END
L'instruction i sera executee si l'expression appartient a
la liste_de_cas i. Les autres ne seront pas executees (on passe
directement au END). L'expression doit etre de type
enumere (pas de reels).En TURBO PASCAL, on accepte une liste_de_cas particuliere qui est ELSE (et doit etre placee en dernier), pour prevoir le cas ou expression n'appartient a aucun des cas cites au dessus. En MS-PASCAL on utilise de meme OTHERWISE.
ex: CASE a*b OF (* avec a et b declares entiers *)
0 : writeln('un des nombres est nul');
1,10,100,1000,10000 :
writeln('le produit est une puissance de 10');
(* 100000 est impossible en TURBO car superieur a MAXINT
*)
END
Attention certains compilateurs n'acceptent pas de passer sur un CASE
avec une valeur prevue dans aucune liste de cas.EXERCICE (ex_calc) faire un programme simulant une calculatrice 4 operations en utilisant CASE pour le choix de l'operation a effectuer.