Le langage Pascal

Structure :

WHILE expression booléenne DO instruction

Elle permet de répéter l'instruction tant que l'expression (ou la variable) booléenne est vraie.

PROGRAM racine_a_deux_decimales (input, output);  
VAR
  nombre, racine : REAL;  
BEGIN  
  writeln('Entrez un réel entre 0 et 10');  
  readln(nombre);  
  racine := 0;  
  WHILE racine * racine < nombre DO  
    racine := racine + 0.01; 
  writeln('La racine de ',nombre,' vaut à peu près',racine)
END.

Il faut noter que si l'expression booléenne est fausse dès le début, l'instruction n'est jamais exécutée (ici si nombre = 0). Attention, Pascal n'initialise pas automatiquement les variables à 0, c'est-à-dire que sans l'instruction racine := 0, le programme risquerait de donner une réponse fausse (racine valant n'importe quoi, il sera en général très supérieur à la racine cherchée).

On ne peut répéter qu'une seule instruction. Mais celle-ci peut être simple (comme dans l'exemple précédent) ou composée (begin - end).

Exerciceex_puiss :
Faire un programme qui affiche les puissances de 2 jusqu'à une valeur maxi donnée par l'utilisateur (par multiplication successive par 2).
Voir la correction

Structure :

REPEAT  
  instruction1;  
  instruction2;  
  ...etc... 
  instructionN  
UNTIL condition

Les N instructions sont répétées jusqu'à ce que la condition soit vérifiée. Même si la condition est vraie dès le début, elles sont au moins exécutées une fois.

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 obéi')  
END.

Quelle que soit la valeur initiale de A (même 482), la question sera au moins posée une fois (plus si vous désobéissez).

Exerciceex_jeu :
Faire 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).
Voir la correction

Structure :

FOR variable := valeur_début TO valeur_fin DO instruction

La variable_énumérée (non réelle) prend la valeur_début, et l'instruction est exécutée. Puis elle est incrémentée (on passe à la suivante, c'est-à-dire que, si elle est entière, on ajoute 1), et ce jusqu'à valeur_fin (comprise).

L'instruction sera donc exécutée (valeur_fin - valeur_début + 1) fois. Si valeur_ fin est inférieure à valeur_début, l'instruction n'est jamais exécutée. Cette forme de boucle est utilisée chaque fois que l'on connaît le nombre de boucles à effectuer.

On peut utiliser un pas dégressif en remplaçant TO par DOWNTO :

for lettre := 'Z' downto 'A' do  
  writeln(lettre)

Dans cet exemple, on écrit l'alphabet à l'envers (en déclarant lettre du type CHAR).

La variable peut être utilisée (mais pas modifiée) dans l'instruction (simple ou composée). Elle est souvent appelée indice de la boucle. Sa valeur est perdue dès que l'on sort de la boucle.

Exerciceex_moy :
Faire un programme qui calcule la moyenne de N nombres. N doit être demandé par un READLN.
(initialiser une variable à 0, y ajouter progressivement chaque note puis diviser par N).
Voir la correction

Structure :

IF condition THEN instruction1 (* CAS 1 *) 
 { ou }  
IF condition THEN instruction1 ELSE 
				  instruction2 (* CAS 2 *)

Si la condition est vraie, alors on exécute l'instruction1 (simple ou composée). Sinon, on passe à la suite (cas 1), ou on exécute l'instruction2 (cas 2).

Remarquez qu'il n'y a pas de ; devant le ELSE.

Exerciceex_jeu_bis :
Modifier le jeu précédent (ex_jeu) en aidant le joueur (en précisant si c'est plus ou c'est moins).
Voir la correction

L'instruction2 peut être composée ou entre autres être une instruction IF :

IF condition1 THEN  
    instruction1  
ELSE IF condition2 THEN  
    instruction2  
ELSE IF condition3 THEN 
	instruction3  
	......  
ELSE instructionN

Un ELSE correspond toujours au dernier IF rencontré (mais dont on n'a pas encore utilisé le ELSE).

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 désire autre chose, utiliser BEGIN et END :

IF cond1 THEN  
BEGIN  
  if cond2 then  
     inst1  
END { le prochain ELSE se rapporte à COND1 puisque l'instruction (composée) suivant THEN est terminée }  
ELSE inst2

Elle évite d'utiliser une trop grande suite de ELSE IF.

Structure :

CASE expression OF { regardez bien où j'ai mis les ; }  
  liste_de_cas1 : instruction1; 
  liste_de_cas2 : instruction2;  
  ..... 
  liste_de_casN : instructionN  
END

L'instruction i sera exécutée si l'expression appartient à la liste_de_casi. Les autres ne seront pas exécutées (on passe directement au END). L'expression doit être de type scalaire (pas de réels).

En Turbo Pascal, on accepte une liste_de_cas particulière qui est ELSE (et doit être placée en dernier), pour prévoir le cas où expression n'appartient à aucun des cas cités au dessus. En MS-Pascal on utilise de même OTHERWISE.

CASE a * b OF { avec a et b déclarés 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 Pascal car supérieur à MAXINT }  
END

Attention, certains compilateurs n'acceptent pas de passer sur un CASE avec une valeur prévue dans aucune liste de cas.

Exerciceex_calc :
Faire un programme simulant une calculatrice à 4 opérations en utilisant CASE pour le choix de l'opération à effectuer.
Voir la correction