CHAPITRE 2

Le langage Pascal

2.1 Historique
Le langage de programmation Pascal a été conçu au début des années 70 par N. Wirth.
Depuis l’utilisation de ce langage s’est développé dans les universités et la communauté
scientifique. Son succès toujours croissant a montré qu’il s’agit du langage qui durant les
années 80, a détrôné les langages tels que FORTRAN, les dérivés de ALGOL. Le Pascal
est facile à enseigner et à apprendre. Il permet d’écrire des programmes très lisibles et
structurés. Il dispose entre autres de facilités de manipulation de données.

2.2 Programmer en Pascal

• Programme
Un programme est une suite d’instructions destinées à l’ordinateur. Or le langage le
langage de l’ordinateur est un langage machine qui n’utilise que deux symboles 0 et
1. On utilise donc un lange de programmation, ici le langage Pascal permettant de
produire des programmes lisibles et facilement modifiables. Ces programmes sont
traduits en langage machine par un compilateur
• Code source
Un programme pascal (prog par exemple) peut être écrit avec un simple éditeur de
texte. Le programme ainsi réalisé est stocké sous forme de fichier avec l’extension

10
 CHAPITRE 2. LE LANGAGE PASCAL

.pas ([Link]).
• Compilation et édition de liens
La version en langage machine d’un programme s’appelle aussi le code objet.
L’éditeur de liens est un programme qui intègre, après la compilation du fichier
source, le code machine de toutes les fonctions utilisées dans le programme et non
définies à l’intérieur. A partir du code objet du programme l’éditeur de liens génère
un fichier exécutable d’extension .exe( [Link]). Le fichier exécutable renferme
alors le programme qui peut être chargée dans la mémoire pour être exécuté.

Figure 2.1 – Cycle de la programmation en Pascal.

2.3 Les constituants élémentaires du Pascal

2.3.1 L’Alphabet
L’alphabet Pascal est constitué des éléments suivants :
– Les majuscules : A, B,..., Z (26 caractères)
– Les minuscules : a, b,..., z (26 caractères)
– Le caractère « blanc »
– Les chiffres : 0, 1,..., 9
– Les symboles spéciaux :

11 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 2. LE LANGAGE PASCAL

– Les opérateurs :
– arithmétiques : + - * /
– relationnels : < ;< ; = ; < = ; >= ; <>
– Les séparateurs : ( ) ; { } ; [ ] ;(* *)
– Le signe« pointeur » : ^
– Les signes de ponctuation : . , ; : ’ ! ?
Remarque :
Le Pascal n’est pas sensible à la casse. Il ne fait pas de distinction entre majuscule et
minuscule. L’écriture begin est correcte ainsi que les écritures suivantes BEGIN ou Begin

2.3.2 Les mots du langage

Un mot est une suite de caractères encadrés par des espaces ou des caractères spéciaux.

[Link] Les mots réservés

– Ne peuvent être redéfinis par l’utilisateur

– Ont une signification précise
– Aident à la construction syntaxique des instructions.
Exemples de mots réservés :

AND BEGIN END CASE PROCEDURE

REPEAT WHILE VAR TYPE FUNCTION
CONST FOR GOTO IF UNTIL
WITH TYPE ARRAY DO ELSE ... ... ...

[Link] Les identificateurs

Un identificateur est un nom donné à un élément du programme introduit par l’uti-

lisateur (constante, variable, fonction, procédure, programme).
Remarque :
– Un identificateur est une suite alphanumérique commençant nécessairement par
une lettre de l’alphabet et ne comportant pas d’espaces.
– Possibilité de lier plusieurs mots à l’aide de ” ”.
– Existence d’une limite au nombre de caractères. (dépend du compilateur)
• Exemples d’identificateurs légaux

12 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 2. LE LANGAGE PASCAL

TERME terme TRES_LONG_TERME X23 Z1Z2

• Exemples d’identificateurs non légaux :
3MOT U.T.C. MOT-BIS A!8 $PROG AUTRE MOT

[Link] Les identificateurs standards

Exemples d’identificateurs standards :

– Fonctions :
COS SIN EXP SQR SQRT SUCC PRED
– Constantes :
MAXINT TRUE FALSE
– Types :
INTEGER REAL BOOLEAN CHAR
– Procédures :
READ WRITE NEW RESET REWRITE
– Fichiers d’entrée-sortie :
INPUT OUTPUT

2.4 Le Langage PASCAL

2.4.1 Caractéristiques globales
• C’est un Langage Typé
– Toutes les variables doivent être pré-déclarées, ce qui évite les erreurs
– Leur type doit être explicitement défini, ce qui enlève toute ambiguı̈té
– Il s’agit d’un langage très ’pédagogique’ et bien adapté pour les débutants
• C’est un Langage Structuré
– Organisation du programme en ”blocs d’instructions” emboı̂tés,
– Utilisation d’identificateurs pour spécifier les blocs,
– Utilisation d’indentations pour visualiser l’architecture du programme.
• C’est un Langage Récursif
– Programmation concise et efficace

13 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 2. LE LANGAGE PASCAL

2.4.2 Structure globale d’un programme PASCAL

– EN-TETE
– DECLARATIONS
1. UNITE
2. ETIQUETTE
3. CONSTANTES
4. TYPES
5. VARIABLES
6. FONCTIONS / PROCEDURES
– BLOC D’INSTRUCTIONS EXECUTABLES

[Link] En-tête

Il s’agit de la première ligne d’un programme PASCAL. L’en-tête commence par le

mot réservé PROGRAM suivi d’un identificateur, éventuellement suivi d’une liste de
paramètres situés entre parenthèses. La ligne est terminée par un point-virgule.
Syntaxe : PROGRAM identificateur (id1,id2, ..., idn) ;
Exemples d’en-tête :

PROGRAM second_degre ;
PROGRAM second_degre (input, output);

[Link] Partie déclarative

La zone de déclaration comprend :

– Déclarations d’unité avec USES
– Déclarations d’étiquette avec LABEL
– Déclarations de constante avec CONST
– Déclarations de type avec TYPE
– Déclarations de variables avec VAR

14 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 2. LE LANGAGE PASCAL

– Déclaration des fonctions et/ou de procédures respectivement avec FUNCTION et

PROCEDURE
L’ordre indiqué doit être impérativement respecté. Les clauses indiquées sont option-
nelles et dépendent des besoins du programmeur. Seuls l’entête et le corps du programme
sont obligatoire.

[Link] Bloc d’instructions

Une instruction est une phrase du langage représentant un ordre ou un ensemble

d’ordres qui doivent être exécutés par l’ordinateur. On distingue :
• Les instructions simples :
– affectation, appels, branchement
• Les instructions structurées
– instructions composées
– instructions itératives
– instructions conditionnelles
Le bloc d’instructions principal commence par ’BEGIN’ et se termine par ’END.’

Exemple 9 Nous présentons ci-dessous un programme qui donne la moyenne de N

nombres entrés au clavier par l’utilisateur, qui précisera le nombre de données qu’il va
taper. A ce stade du cours, il n’est pas nécessaire de comprendre le contenu de ce pro-
gramme. Il suffit simplement de reconnaı̂tre l’architecture globale décrite précédemment
(déclarations de variables, blocs, indentations, begin...end).

program MOYENNE ; {En-t^

ete}
USES crt;
var DONNEE, SOMME, MOYENNE : real;
I, N : integer ; {partie déclarative}
begin {début du bloc d’instructions}
clrsrc;
writeln(’entrer le nombre de données’);
readln(N); {instruction}
if N > 0 then
begin
SOMME := 0;
for I := 1 to N do

15 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 2. LE LANGAGE PASCAL

begin
read(DONNEE);
SOMME := SOMME + DONNEE;
end;
MOYENNE := SOMME / N;
writeln(’moyenne =’,MOYENNE);
end
else
writeln(’pas de donnees’);
end. {Fin du bloc d’instructions}

2.4.3 Déclarations de constantes

En Pascal, tout symbole utilisé dans un programme doit être explicitement déclaré.
Une constante est désignée par un identificateur et une valeur, qui sont fixées en début
de programme, entre les mots clés CONST et VAR. La valeur ne peut pas être modifiée,
et ne peut pas être une expression.
Syntaxe

identificateur = valeur_constante;

ou

identificateur : type = valeur_constante;

Dans la première forme, le type est sous-entendu (si il y a un point, c’est un réel, sinon
un entier ; si il y a des quotes, c’est un caractère (un seul) ou une chaı̂ne de caractères
(plusieurs).
L’utilisation de constantes en programmation est vivement conseillée. Elles permettent :
– une notation plus simple
Exemple : PI à la place de 3,141592653 CONST pourcent : real = 33.3;
– La possibilité de modifier simplement la valeur spécifiée dans la déclaration au lieu
d’en rechercher les occurrences, puis de modifier dans tout le programme.

16 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 2. LE LANGAGE PASCAL

Exemple 10 Déclaration de constantes

– Déclarations de type numérique

const DEUX = 2;
PI = 3.14;
– Déclarations de type booléen
VRAI = true;
FAUX = false;
– Déclarations de type caractère
CARA = ’A’;

– Déclarations de type chaı̂ne de caractères

PHRASE = ’Vaut mieux une fin effroyable qu’’un effroi sans fin’;

2.4.4 Déclaration de types

Un type est un ensemble de valeurs que peut prendre une donnée.

[Link] Les types standards

Un type standard est un type qui est normalement connu de tout langage Pascal et
qui n’a donc pas été déclaré par l’utilisateur. Les différents types standards :

Le type entier : integer

• Surn bits, il sera possible d’utiliser des entiers compris entre −2n−1 et (2n−1 − 1)
• Donc sur 16 bits, les entiers seront compris entre −32768 et 32767 (−215 et
+215 − 1).
• Donc sur 32 bits, les entiers seront compris entre −2147483648 et +2147483647
(−231 et +231 − 1).

17 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 2. LE LANGAGE PASCAL

• Opérateurs sur les entiers :

abs(x) valeur absolue de x
pred(x) x − 1
succ(x) x + 1
odd(x) true si x est impair, false sinon.
sqr(x) le carrée de x.
+ x identité.
- x signe opposé
x + y addition
x - y soustraction.
x * y multiplication.
x / y division, fournissant un résultat de type réel.
x div y dividende de la division entière de x par y.
x mod y reste de la division entière, avec y non nul.
Remarques
– Attention, les opérateurs /, div et mod, produisent une erreur à l’exécution si
y est nul.
– Lorsqu’une valeur (ou un résultat intermédiaire) dépasse les bornes au cours
de l’exécution, on a une erreur appelée débordement arithmétique.
Le type réel : real
• Utilisable pour représenter les rééls et les entiers élevés. Le domaine de définition
dépend de la machine et du compilateur utilisés.
• 0.0 ; −21.4E3 (= −21, 4 × 103 = −21400) ; 1.234E − 2 (= 1, 234 × 10−2 )
• Opérateurs sur un argument x réel : abs(x), sqr(x), +x, -x. Si l’un au moins
des 2 arguments est réel, le résultat est réel pour : x - y, x + y, x * y.
• Résultat réel que l’argument soit entier ou réel : x / y (y doit être non nul) ;
fonctions sin(x), cos(x), exp(x), ln(x), sqrt(x) (square root, racine carrée).
• Fonctions prenant un argument réel et fournissant un résultat entier : trunc(x)
(partie entière), round(x) (entier le plus proche). Si le résultat n’est pas représen-
table sur un integer, il y a débordement.
Le type booléen : boolean
• Définit les valeurs logiques
• Constantes : true (vrai) et false (faux)
• Ce type permet la manipulation avec des opérateurs logiques

18 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 2. LE LANGAGE PASCAL

• Opérateurs booléens : not (négation), and (et), or (ou).

x y not x x and y x or y
true true false true true
true false false false true
false true true false true
false false true false false

• Opérateurs de comparaison (entre 2 entiers, 2 réels, 1 entier et 1 réel, 2 chars, 2

booléens) : <, >, <=, >=, = (égalité, à ne pas confondre avec l’affectation :=),
<> (différent).
Le resultat d’une comparaison est un booléen. On peut comparer 2 booléens entre
eux, avec la relation d’ordre false < true.
• En mémoire, les booléens sont codés sur 1 bit, avec 0 pour false et 1 pour true.
De là les relations d’ordre. Les opérateurs booléens not, and, or s’apparentent
approximativement à (1 − x), ×, +.
Le type caractère : char
• C’est un unique caractère entouré d’apostrophes
• Ensemble des valeurs de ce type :
– alphanumériques : ’a’ . . ’z’ ’A’ . . ’Z’ ’0’ . . ’9’
– caractère blanc : ’ ’
– Le choix et l’ordre des 256 caractères possible dépend de la machine et de la
langue. Sur PC, on utilise le code ASCII, où ’A’ est codé par 65, ’B’ par 66,
’a’ par 97, ’ ’ par 32, ’{’ par 123, etc.
– Les opérateurs sur les chars sont :
ord(c) numéro d’ordre dans le codage ; ici ¡ code ascii ¿.
chr(a) le résultat est le caractère dont le code ascii est a.
succ(c) caractère suivant c dans l’ordre ascii , chr(ord(c)+1)
prec(c) caractère précédent c dans l’ordre ascii.
– On peut remplacer chr(32) par #32, mais pas chr(i) par #i.
Le type chaı̂ne de caractère : string ou varying
– Ce type n’est pas disponible sur tous les compilateurs
– Possibilité d’accéder à un caractère particulier de la chaı̂ne, en indiçant la variable
qui y fait référence

19 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 2. LE LANGAGE PASCAL

Exemple 11
phrase <--- ’ il fait beau’
phrase[5] <--- ’a’

[Link] Les types scalaires et non standards

Principe : on fabrique les types dont on a besoin par l’intermédiaire du mot réservé
TYPE. Les types scalaires standard sont les entiers et les caractères.
Le Type énuméré
Un type énuméré est une séquence ordonnée d’identificateurs.
Syntaxe : TYPE identificateur = (id1, id2,..., idn) ;

Exemple 12 Type COULEUR = (jaune, vert, rouge, bleu, marron);

SEMAINE=(lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche);
SEXE =(masculin, féminin);
VOYELLE = (A, E, I, O, U);

Le mot réservé TYPE ne doit être écrit qu’une seule fois.

Avec un type énuméré, on peut donc donner la liste des valeurs possibles les unes après
les autres. Les autres types énumérés déjà définis sont les boolean, les char, mais aussi
les integer. Tous ces types se comportent comme des entiers, et la déclaration qu’on a
faite dans l’exemple précédent est traduite sous la forme lundi = 0, mardi = 1 et ainsi
de suite. L’avantage est qu’il existe des fonctions définies sur tous les types énumérés :
– la fonction ORD, qui donne le numéro dans la liste de déclaration (ord(mardi)=1,
on commence à 0) ;
– les fonctions SUCC et PRED, qui donnent le successeur et le prédecesseur dans la liste :
succ(mardi)= mercredi, pred(samedi)=vendredi. Attention, pred(lundi) et
succ(dimanche) ne sont pas définis. On ne sait pas ce qu’ils valent ;
– les opérateurs de comparaison
– les boucles for ;
Il faut faire attention, les fonctions readln et writeln ne marchent pas avec ces types.
D’autre part, deux types énumérés différents ne peuvent contenir le même identifi-
cateur. =⇒ Ensembles énumérés disjoints

20 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 2. LE LANGAGE PASCAL

Le type intervalle
Un type intervalle est un sous-type d’un type scalaire déjà défini.
Syntaxe : TYPE identificateur = [borne inf].. [borne sup] ; Points impor-
tants :
• Valeurs autorisées : toutes celles de l’intervalle
• Deux sortes de type intervalle :
– les types issus d’un type énuméré standard
– les types issus d’un type énuméré déclaré.

Exemple 13 Nous présentons ci-dessous des exemples issus d’un type standard.
– Intervalle d’entiers :
Type DECIMAL = 0 .. 9 ;
OCTAL = 0 .. 7 ;
AGE = 0 .. 150 ;
– Intervalle de caractères :
Type ABC = ’A’ .. ’C’ ;
MAJ = ’A’ .. ’Z’ ;
– A présent, voici quelques exemples issus d’un type non-standard
Type OUVRABLE = lundi .. vendredi ;
WEEK-END = samedi .. dimanche ;
LETTRES = ’A’ .. ’Z’ ;

Ordre ascendant requis : borne-inf doit être placé avant borne-sup dans le type énuméré
source.

Exemple 14 Déclarations de type intervalle incorrectes :

Type OCTAL = 7 .. 0 ;
OUVRABLE = vendredi .. lundi ;

Pas de type intervalle issu du type réel (non scalaire) !

2.4.5 Déclaration de variables

Une variable est une donnée manipulée par un programme et pouvant être modifiée.
Elle peut être :

21 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 2. LE LANGAGE PASCAL

– une donnée d’entrée ;

– le résultat final d’un calcul ;
– un résultat intermédiaire de calcul.
Déclarer une variable, c’est définir l’ensemble des valeurs qu’elle peut prendre. Toutes
les variables utilisées dans un programme doivent être déclarées. Une variable représente
un objet d’un certain type ; cet objet est désignée par un identificateur. Toutes les va-
riables doivent être déclarées après le VAR.
Deux façons pour déclarer une variable :
– à l’aide d’un type standard ou d’un type pré-déclaré
– par une déclaration explicite et spécifique à cette variable de l’ensemble des valeurs
qu’elle peut prendre.
Syntaxe : VAR identificateur : type ;
– VAR ne peut apparaı̂tre qu’une seule fois
– Possibilité de grouper plusieurs variables pour le même type
– Séparation des variables par une virgule

Exemple 15 Déclarations de variables

– avec référence à un type existant
var JOUR : semaine ;
A, B, C : real ;
I, J, K : integer ;
CONGE : week-end ;
VIVANT : boolean ;

– avec déclaration locale explicite :

var LETTRE : ’A’ . . ’Z’ ;
FEUX : (vert, orange, rouge) ;

Exemple 16 Déclaration de constante, type et variable

const JOUR_MAX = 31 ;
AN_MIN = 1901 ;
AN_MAX = 2000 ;
type SIECLE = AN_MIN . . AN_MAX ;

22 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 2. LE LANGAGE PASCAL

SEMAINE = (LUNDI, MARDI, MERCREDI,JEUDI,VENDREDI,SAMEDI, DIMANCHE) ;

ANNEE = (JANVIER, FEVRIER, MARS, AVRIL, MAI,JUIN, JUILLET, AOUT,
SEPTEMBLE, OCTOBRE , NOVEMBRE, DECEMBRE);
var MOIS : année ;
JOUR : semaine ;
N_JOUR : 1 .. jour_max ;
AN : siecle ;
OUVRABLE : lundi .. vendredi ;
I, J : integer ;
N_ETUDIANT : 1 .. maxint ;

2.4.6 Instructions composées

[Link] Définition

Les instructions composées permettent de regrouper, dans un même bloc, un

ensemble d’instructions qui seront exécutées au même niveau.
Syntaxe : Séquence de deux ou plusieurs instructions comprises entre
BEGIN et END et séparées par des points virgules

[Link] Instruction d’affectation

<VARIABLE>:=<expression>
– Evaluation de l’expression (calcul)
– Puis affectation (rangement) dans la variable (identificateur)
Nécessité d’avoir des types compatibles (les mélanges de types sont interdits) Ne
pas confondre ” :=”, l’opérateur d’affectation et ”=”, l’opérateur de test.

Exemple 17 Soit X une variable de type integer et on lui donne comme valeur 10
X := 10 signifie que l’on affecte la valeur 10 à la variable X donc X vaut 10.
On peut tester si X est égal à une certaine valeur avant d’effectuer un calcul :
Si X = 3 alors X := X / 2
Ici X vaut toujours 10 car le test X = 3 n’est pas vérifié (puisque la valeur 10 a été
placée dans X)

A la déclaration, les variables ont une valeur indéterminée. On initialise les variables
juste après le BEGIN pricncipal (on ne peut pas le faire dans la déclaration). Utiliser la

23 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 2. LE LANGAGE PASCAL

valeur d’une variable non initialisée est une erreur grave !

Exemple 18
VAR
a, b, c : integer;
BEGIN
{ Partie initialisation }
b := 5;
{ Partie principale }
a := b + c; { ERREUR, c n’a pas été initialisée’ }
END.

L’opération identificateur := expression; est une affectation. On n’a pas le droit

d’écrire id1 := id2 := expr , ni expr := id ni expr1 := expr2 .

2.4.7 Opérateurs et Fonctions arithmétiques

[Link] Opérateurs disponibles

Opérateur Description
+ somme
- soustraction
* multiplication
/ division
DIV division entière ( 5 div 3 = 1 )
MOD modulo ( 5 mod 3 = 2 )

Tableau 2.1 – Opérateurs disponibles

Exemple 19 var A, B, C, D : real;

I, J, K : integer;
begin
A := 7.4 ; B := 8.3 ;
C := A + B ;
D := A / B + C ;
I := 42 ; J := 9 ;
K := I mod J ; { K vaut 6 }
end.

24 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 2. LE LANGAGE PASCAL

[Link] Expressions

Une expression désigne une valeur, exprimée par composition d’opérateurs appli-
quées à des opérandes, qui sont : des valeurs, des constantes, des variables, des appels de
fonction ou des sous-expressions.

Exemple 20 Etant donnée une variable x, une constante max et une fonction cos(),
chaque ligne contient une expression :

5
x + 3.14
2 * cos(x)
(x < max) or (cos(x-1) > 2 * (x+1))
2.08E3 * x
(x>2) OR (x<8)

Type des expressions bien formées

Une expression doit être bien formée pour que l’on puisse trouver sa va- leur. Par
exemple, 3 * ’a’ - true n’est pas bien formée, et la compilation Pascal échouera. L’ex-
pression bien formée a un type, qui dépend des règles d’évaluation de l’ex- pression.
Soit r un réel, i un entier, e une constante entière, c un caractère. L’expression
(round(r+1) > (i/e)) or (c < ’a’)
est bien formée, et sont type est booléen comme on le montre ici :

Remarque Le fait qu’une expression soit bien formée n’implique pas que son évaluation
est sans erreur, ce qui peut être le cas ici si e est nul.

25 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 2. LE LANGAGE PASCAL

Règles d’évaluation
L’expression a + b * c est évaluée a + (b * c) et non pas (a + b) * c : ceci parce
que le * est prioritaire par rapport à +. On classe les différents opérateurs par ordre
de priorité, les opérateurs de plus forte priorité étant réalisés avant ceux de plus faible
priorité. Lorsque deux opérateurs sont de priorité égale, on évalue de gauche é droite. Par
exemple a + b - c est évaluée (a + b) - c, et non pas a + (b - c). Voici la table
des priorités classées par ordre décroissant, les opérateurs sur une même ligne ayant une
priorité égale.

() fonction() primaire
+ - not unaire
* / div mod and multiplicatif
+ - or additif
= <> < <= >= > relation

Remarque Est-ce que l’expression a < b or c <= d est bien formée ? Quel est son
type ?
Réponse : non ! Ecrire une telle expression booléenne sans parenthèses est une erreur
classique. En effet dans la table de priorités, l’opérateur or a une priorité plus élevée que
les opérateurs < et <=, et donc l’expression sera évaluée a < (b or c) <= d , ce qui est
faux. L’expression bien formée est ici (a < b) or (c <= d) .

[Link] Fonctions arithmétiques

[Link] Fonctions logiques

2.5 Entrées / Sorties

Ce sont des échanges d’informations entre la mémoire (variables et constantes) et les
périphériques (clavier, écran ...). Types autorisés : réel, booléen, caractères et chaı̂nes de
caractères.
Le clavier et l’écran sont gérées comme des fichiers particuliers : ce sont des fichiers
texte, toujours ouverts et sans fin ; ils sont désignés par les variables prédéfinies input et
output (dont on ne se sert quasiment jamais).
Pour transmettre des données saisies au clavier à un programme (entrées) ou pour
afficher à l’écran les données par un programme (sorties), il faut faire appel à un ensemble

26 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 2. LE LANGAGE PASCAL

Fonction Description
ABS (X) valeur absolue de X
ARCTAN (X) arctangente de X
CHR (X) caractère dont le numéro d’ordre est X
COS (X) cosinus de X
EXP (X) exponentielle de X
LN (X) logarithme népérien de X
ORD (X) numéro d’ordre dans l’ensemble de X
PRED (X) prédécesseur de X dans son ensemble
ROUND (X) arrondi de X
SIN (X) sinus de X
SQR (X) carré de X
SQRT (X) racine carrée de X
SUCC (X) successeur de X dans son ensemble
TRUNC (X) partie entière de X

Tableau 2.2 – Fonctions arithmétiques

Fonction Description
EOF (X) vrai si la fin de fichier X est atteinte
EOLN (X) vrai si fin de ligne du fichier
ODD (X) vrai si X est impair, faux sinon

Tableau 2.3 – Fonctions logiques

de fonctions appartenant à l’unité d’entrées/sorties. Il faut donc faire apparaı̂tre en début

de programme l’instruction suivante :
USES crt ;

2.5.1 Sortie (Ecriture)

On utilise la fonction write ou writeln pour l”affichage formaté des données ; For-
maté signifie que l’on contrôle la forme et le format des données La fonction admet la
syntaxe suivante :
Write(argument1, argument2,..., argumentn)
ou
Writeln(argument1, argument2,..., argumentn)
avec argument1,..., argumentn : les arguments à afficher

Exemple 21 write(’bonjour ’)

27 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 2. LE LANGAGE PASCAL

writeln(’monsieur’)
a :=2+3 ;
writeln(’la somme de 2 + 3 donne :’,a) ;
La fonction write écrit ici à l’écran les arguments (chaı̂ne de caractères, constante,
variable) La fonction writeln écrit la même chose. La seule différence est que à la fin
de l’écriture du dernier argument, il y a un passage à la ligne suivante

−→ Trois écritures équivalentes :

writeln (a, b, c, d);

write (a, b, c, d); writeln;
write(a); write(b); write(c); write(d); writeln;

Le résultat de l’affichage dépend du type du paramètre :

Exemple 22
VAR e : integer; c : char; b : boolean; r : real; s : string[32];
BEGIN
e := 12; c := ’A’; b := true; r := 23.0; s := ’toto’;
writeln (e, ’|’, c, ’|’, b, ’|’, r, ’|’, s);
END.
affiche : 12|A|TRUE|2.300000E+01|toto

Formatage de l’inpression des variables

– Soit v un entier, un booléen, un caractère ou un string. write(v:8) dit à write
d’afficher v sur au moins 8 caractères. Si le nombre de caractères (signe éventuel
compris) est > 8, v est complétement affiché ; si il est < 8, des espaces sont rajoutés
à gauche pour compléter.
Ainsi writeln (e:5, ’|’, c:3, ’|’, b:5, ’|’, s:6); affiche :
12| A| TRUE| toto
– Soit r un réel.
write(r:10); dit à write d’afficher r en notation scientifique, sur au moins 10
caractères, signes de la mantisse et de l’exposant compris. Cette fois c’est d’abord le
nombre de chiffres après la virgule qui change de 1 à 10, puis au besoin des espaces
sont ajoutés à gauche. De plus le dernier chiffre de la mantisse affichée est arrondi.
r := 2 / 3;
writeln (r:8, ’|’, r:10, ’|’, r:18 );

28 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 2. LE LANGAGE PASCAL

affiche :
6.7E-01| 6.667E-01| 6.6666666667E-01
– Autre formattage de r réel. write(r:8:4); dit à write d’afficher r en notation
simple, sur au moins 8 caractères, dont 4 chffres après la virgule (le dernier étant
arrondi).
Ainsi writeln (r:8:4); affiche :
0.6667

2.5.2 Entrées (Lecture )

On utilise la fonction readln pour la saisie des données depuis le clavier La fonction
admet la syntaxe suivante :
readln(argument1, argument2,..., argumentn)
avec argument1,..., argumentn : les arguments. Le programme va lire ce que l’uti-
lisateur a tapé et va stocker les valeurs dans les variables argument1,..., argumentn

Exemple 23
Write(’Entrez un nombre entier : ’) ;
Readln(a) ;
Writeln(’vous avez entré la nombre ’,a) ;
Write(’Entrez 3 nombre réels : ’) ;
Readln(b,c,d) ;

La fonction Readln lit des valeurs sur le périphérique d’entrée standard (clavier) les
interprète dans le format de la variable et les range dans les arguments spécifiés. A chaque
valeur saisie il faut valider par la touche entrée pour que la saisie soit prise en compte.
Remarque :
Readln(...);
=⇒ passage à la ligne suivante en ignorant ce qui reste sur la ligne
Readln ; peut être employé sans paramètre
La procédure read() permet de lire un ou plusieurs paramètres. readln() fait la
même chose puis fait un readln ;
−→Trois écritures équivalentes :

readln (a, b, c, d);

29 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 2. LE LANGAGE PASCAL

read (a, b, c, d); readln;

read(a); read(b); read(c); read(d); readln;

Remarques
– L’exécution d’une de ces lignes, on peut rentrer les données en les séparant par des
espaces, des tabulations ou des retours chariot ←-.
– Il faut que les données lues correspondent au type attendu de chaque variable, sinon
il y a une erreur à l’exécution.

2.5.3 Lecture directe du clavier

Il existe une fonction avec laquelle on peut entrer une valeur sans valider avec la
touche entrée. Cette entrée manipule uniquement des caractères. Il faut donc déclarer
des variables de type caractère

Exemple 24
C:=readkey; {lit une touche au clavier}
C:=upcase(readkey); {lit une touche au clavier et la convertit en minuscule}

30 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 3

Structures de contrôle

3.1 Introduction
Dans un langage impératif, on peut définir l’état d’un programme en cours d’exécution
par deux choses :
– L’ensemble des variables du programme ;
– L’instruction qui doit être exécutée
L’exécution d’un programme est alors une séquence d’affectations qui font passer d’un
état initial à un état final considéré comme résultat. Les structures de contrôle définissent
comment les affectations s’enchaı̂nent séquentiellement.

3.2 La structure séquentielle

3.2.1 La notion de séquence
Une structure séquentielle ou séquence est une suite d’instructions rangées dans l’ordre
où elles sont écrites. On parle d’une structure séquentielle chaque fois qu’il s’agit d’une
séquence d’instructions simples devant être parcourues l’une après l’autre. Il apparaı̂t
immédiatement qu’une séquence est une structure algorithmique très élémentaire. Ainsi
par exemple, si S1 et S2 représentent deux instructions, leur composition est notée :

31
 CHAPITRE 3. STRUCTURES DE CONTRÔLE

S1; S2;
respectivement :

S1;
S2;

Ce qui signifie que :

– les instructions S1 et S2 sont exécutées une par une,
– chacune d’elles est exécutée exactement une fois,
– l’ordre dans lequel elles sont exécutées est le même que celui dans lequel elles ont
été écrites,
– terminer l’instruction S2 implique de finir la structure séquentielle.
Il apparaı̂t immédiatement que dans une structure séquentielle l’ordre des instructions
joue un rôle fondamental. Ainsi par exemple, dans la séquence d’[Link] par
exemple, dans la séquence d’instructions

X1 := 2;
X2 := X1+3;
Writeln( X2 );

d’abord la valeur 2 est affectée à la variable X1, puis, la valeur 5 est affectée à la variable X2
et le contenu de la variable X2 est écrit sur le fichier standard de sortie, c’est-à-dire l’écran.
Il n’est pas possible de revenir en arrière pour recommencer l’opération. L’exécution d’une
instruction déterminée n’est possible que lorsque toutes les instructions qui la précèdent
ont été exécutées.
Il est évident que la notion de séquence peut être généralisée pour un nombre quel-
conque N d’instructions : S1; S2; S3; ... ; SN;
La figurereprésente une traduction graphique de la structure séquentielle. Une telle
représentation est appelée Algorigramme , Ordinogramme ou encore Organigramme.

Exemple 25 Calcul d’un produit de 2 nombres

Algorithm Produit;
Variable
a,b : réel; (*opérandes*)
p : réel ; (* résultat du produit*)
Début

32 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 3. STRUCTURES DE CONTRÔLE

Figure 3.1 – Algorigramme de la structure séquentielle.

Ecrire(’Saisir le nombre a ’);

Lire(a);
Ecrire(’Saisir le nombre b ’);
Lire(b);
p:=a * b;
Ecrire (p);
Fin.

3.2.2 Les instructions composées

Une instruction composée est une série de N (N ≥ 2) instructions qui doivent être
exécutées en séquence. Une instruction composée est délimitée par les mots réservés
BEGIN et END qui indiquent respectivement le début et la fin de l’instruction composée.
Voici quelques exemples d’instructions composées :

Exemple 26 BEGIN
Readln( X, Y );
Writeln( X, Y );
Z := X;
X := Y;

33 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 3. STRUCTURES DE CONTRÔLE

Y := Z;
Writeln( X, Y )
END;

Exemple 27 S1;
S2
BEGIN S31; S32; S33 END;
S4;
BEGIN
S51;
BEGIN S521; S522 END;
S53
END;
S6;

3.3 Les structures alternatives

Une instruction alternative permet de faire le choix entre une, deux ou plusieurs ac-
tions suivant qu’une certaine condition est remplie ou non. Une telle structure algorith-
mique est encore appelée sélection. On distingue deux types d’instructions alternatives :
– le choix simple (instruction IF ) et
– la sélection multiple.( instruction CASE)

3.3.1 Le choix simple

Syntaxe :
En pseudo-code

SI <condition> ALORS
<bloc_instructions1>
SINON
<bloc_instructions2>

en PASCAL

IF <condition> THEN

34 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 3. STRUCTURES DE CONTRÔLE

<bloc_instructions1>
ELSE
<bloc_instructions2>

Cette instruction exprime les instructions qui sont exécutées suivant que la condition
(l’expression booléenne) ¡condition¿ est remplie. Elle est interprétée de la manière sui-
vante :
SEMANTIQUE :
« Si la condition <condition> est vraie, alors exécuter l’instruction qui suit le mot réservé
THEN, sinon exécuter l’instruction qui suit le mot réservé ELSE.” »
Dans cette interprétation, l’exécution des instructions <bloc_instructions1>et
<bloc_instructions2> est mutuellement exclusive ce qui signifie que seule une des deux
instructions sera exécutée.
Points importants :

– Surtout pas de point virgule immédiatement avant le ELSE ! ! !

– Instruction alternative : facultative En effet les deux formes suivantes sont équivalentes.
– IF < condition > THEN
BEGIN
< instruction >;
END;

– IF < condition > THEN

BEGIN
< instruction >;
END
ELSE ; { rien }

• Valeur de la condition : booléenne

• Blocs d’instructions :
– Instructions simples
– Instructions structurées
– Instructions composées.

35 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 3. STRUCTURES DE CONTRÔLE

Organigrammes :

– sans SINON

Figure 3.2 – Organigramme de la sélection sans alternative

– avec SINON

Figure 3.3 – Organigramme de la sélection avec alternative

Exemple 28 Calcul d’une racine carrée (avec SI... ALORS)

Algorithm SI_ALORS;
Variable
x: réel ; (*opérande*)
r: réel ; (*résultat de la racine carrée*)
Début
Ecrire (’Saisir le nombre x’);
Lire (x);
Si x > 0 Alors

36 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 3. STRUCTURES DE CONTRÔLE

Début
r := racine (x);
Ecrire (r);
Fin
Fin.

Exemple 29 Calcul d’une racine carrée (SI... ALORS... SINON)

Algorithm SI_ALORS_SINON;
Variables :
x: réel; (*opérande*)
r: réel ;(*résultat de la racine carrée*)
Début
Ecrire(’Saisir le nombre x’);
Lire (x);
Si x < 0 Alors
Ecrire (’x est négatif’)
Sinon
Début
r := racine (x);
Ecrire (r);
Fin

Fin.

Ambiguı̈tés syntaxiques

Il faut bien percevoir que la formulation de l’instruction IF n’est pas toujours sans am-
biguı̈té. Ainsi par exemple, l’ambiguı̈té syntaxique de la construction :
IF < expr1 > THEN IF < expr2 > THEN < st1 > ELSE < st2 >;
peut être évitée par le réécriture suivante :

IF < expr1 > THEN

IF < expr2 > THEN < st1 >
ELSE < st2 >;

37 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 3. STRUCTURES DE CONTRÔLE

On dit ici que les instructions IF sont imbriquées.

Afin d’éviter des ambiguı̈tés de ce genre lors de la lecture d’un programme, il est vive-
ment recommandé de bien mettre un THEN et un ELSE de la même structure alternative au
même niveau vertical afin de ne pas les mélanger entre eux. Cette façon de procéder est
appelée indentation ou paragraphage. L’identation est très souvent effectuée de manière
automatique par un outil qui accompagne le compilateur (indenteur ou paragrapheur).
En général, une telle ambiguı̈té syntaxique est écartée définitivement soit en utilisant
les parenthèses symboliques BEGIN et END, soit en respectant la règle suivante :
Règle : « ”La partie ELSE se rapporte toujours au mot réservé IF précédent le plus
proche pour lequel il n’existe pas de partie ELSE. »
Dans une construction de structures alternatives imbriquées il doit y avoir autant de
mots THEN que de mots IF. Ainsi par exemple, dans le texte Pascal :
IF N>0 THEN IF A>B THEN Max := A ELSE Max := B;
la partie ELSE se rapporte au mot réservé IF situé à l’intérieur de la séquence ce qui peut
être élucidé en écrivant :

IF N>0 THEN
IF A>B THEN Max := A
ELSE Max := B;

Si ce n’est pas ce qu’on a voulu exprimer, il faut se servir des parenthèses symboliques
BEGIN et END pour forcer des appartenances respectives comme par exemple :

IF N>0 THEN
BEGIN
IF A>B THEN Max := A
END
ELSE Max := B;

Le lecteur se rendra bien compte de la signification différente des deux constructions

précédentes.

Exemple 30 Equation du premier degré avec C=0

Ecrire un programme qui résoud une équation du premier degré Ax+b=0 qui lit les valeurs
de A et B entrées par l’utilisateur.

38 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 3. STRUCTURES DE CONTRÔLE

Program Premier_Degre;
Var
A, B : real;
Begin
write(’entrez les coefficients A et B : ’);
readln(A,B);
if A=0 then {évaluation de la condition}
if B=0 then
writeln(’Indéterminé !’)
else
writeln(’Impossible !’)
else
writeln(’La solution est : ’,-B/[Link]);
End.

Exemple 31 Maximum de deux nombres

Ecrire un programme qui calcule le maximum de deux nombres entrés au clavier.

Program MAXIMUM_DEUX ;
var X,Y : real ;
MAX : real ;
Begin
writeln(’Tapez les deux nombres:’)
read (X, Y) ;
if X > Y then {évaluation de la condition}
MAX := X
else
MAX := Y ;
writeln(’Le plus grand nombre est ’,MAX);
End.

3.3.2 La sélection multiple : le CAS...

Cette méthode est utilisée pour tester une solution parmi N. Par exemple, au cas où
un menu est proposé à l’utilisateur (1) pour lire, 2) pour écrire, 3) pour calculer, 4) pour

39 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 3. STRUCTURES DE CONTRÔLE

sortir etc...), il est important de tester si l’utilisateur a tapé 1, 2, 3 ou 4. Au lieu d’utiliser

plusieurs IF... THEN... ELSE... imbriqués, il est préférable de choisir une sélection
multiple (CASE en Pascal). Ainsi au lieu d’écrire :

IF reponse=1 THEN
Instructions de lecture...
ELSE
IF reponse=2 THEN
Instructions d’écriture...
ELSE
IF reponse=3 THEN
instructions de calcul...

avec un organigramme représenté par la figure 3.4,

Figure 3.4 – Organigramme de la structure avec IF imbriqués

Il serait préférable d’écrire :

40 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 3. STRUCTURES DE CONTRÔLE

CASE reponse OF
1 : Instructions de lecture...
2 : Instructions d’écriture...
3 : instructions de calcul...
End;

L’instruction de sélection multiple ou instruction CASE encore appelée analyse par cas
est une généralisation supplémentaire de l’instruction IF. Elle est fréquemment utilisée
en programmation s’il faut faire le choix entre plus de deux alternatives. Sa formulation
est simplifiée par l’instruction CASE.
Syntaxe

en pseudo-code

CAS variable PARMI

constante1 : suite d’instructions1
constante2 : suite d’instructions2
intervalle1 : suite d’instructions3
...
SINON suite d’instructions par defaut
END;

en Pascal

CASE variable OF
constante1 : suite d’instructions1
constante2 : suite d’instructions2
intervalle1 : suite d’instructions3
...
ELSE suite d’instructions par defaut
END;

La séquence précédente est interprétée de la manière suivante :

« Si variable prend la valeur constante1 , alors exécuter la suite d’instructions 1. Si
variable prend la valeur constante2, alors exécuter la suite d’instructions2, si variable
est dans l’intervalle1 alors, exécuter la suite d’instructions3 etc. , sinon exécuter la
suite d’instructions par défaut qui suit le mot réservé ELSE. »

41 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 3. STRUCTURES DE CONTRÔLE

– Comme dans l’instruction IF, l’exécution de chaque branche est mutuellement ex-
clusive.
– La variable variable est appelée sélecteur et doit être d’un type scalaire.
– Les constantes CASE doivent être toutes différentes et du même type que le sélecteur.
Elles sont interprétées comme des étiquettes.
– Seules les égalités sont possibles au niveau du test (Pas de comparaisons de type
<,>,<=,>= ou <>) On peut néanmoins utiliser des intervalles .
– On peut donner une liste de constantes, ou des intervalles de constantes. Attention,
chaque valeur possible ne doit être représentée qu’une fois au plus (sinon il y a erreur
à la compilation). Par exemple, on ne peut pas faire des intervalles se chevauchant,
comme 3..6 et 5..10, les cas 5 et 6 étant représentés 2 fois.

Exemple 32 Simuler une calculatrice

Program calculette ;
var A, B : real ;
RESULTAT : real;
TOUCHE : char;
Begin
write(’entrez une opération ’);
write(’(taper un nombre, un opérateur puis un nombre) : ’);
readln(A,TOUCHE,B);
case TOUCHE of
’+’ : RESULTAT:= A+B;
’-’ : RESULTAT:= A-B;
’*’ : RESULTAT:= A*B;
’/’ : RESULTAT:= A/B;
end;
writeln(A, TOUCHE, B,’ = ’, RESULTAT);
end.

Exemple 33 Ecrire un programme qui lit un caractère, puis classe ce caractère comme
espace, lettre, digit ou autre.

PROGRAM caractere;
TYPE nat_t = (Espace, Lettre, Digit, Autre);

42 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 3. STRUCTURES DE CONTRÔLE

VAR nat : nat_t; { nature }

c : char;
BEGIN
write (’Rentrez un caractere :’);
readln(c);
{ analyse de c }
case c of
’a’..’z’, ’A’..’Z’, ’_’ : nat := Lettre;
’0’..’9’ : nat := Digit;
’ ’ : nat := Espace;
else nat := Autre;
end; { case c }
{ affichage de nat }
case nat of
Espace : writeln (’Espace’);
Lettre : writeln (’Lettre’);
Digit : writeln (’Digit’);
Autre : writeln (’Autre’);
else { case nat }
writeln (’Erreur case nat : ’, ord(nat), ’ non prevu’);
end; { case nat }
END.

3.3.3 Le concept de condition

Une condition est une expression booléenne. La valeur d’une condition est du type
booléen dont les seules valeurs sont les valeurs de vérité True et False. Une valeur
booléenne est obtenue en appliquant les opérateurs booléens AND, OR et NOT ainsi que les
opérateurs relationnels =, <>, <, <=, >, >= à des opérandes booléennes.
On envisage les conditions de relation simple et les conditions de relation composée.
Dans une condition de relation simple deux expressions arithmétiques sont comparées
au moyen des opérateurs relationnels. Une condition de relation composée se construit
au moyen de conditions de relation simple reliées les unes aux autres par les opérateurs
booléens.

43 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 3. STRUCTURES DE CONTRÔLE

Exemple 34 NOT( A<=B )

( A>3 ) OR ( B<5 )
( X>3 MOD 4 ) AND ( Sqr( B )<=6 )

L’opérateur AND permet de simplifier l’écriture d’une série d’instructions IF imbriquées

de la forme suivante :

IF < expression 1 > THEN

BEGIN
IF < expression 2 > THEN
BEGIN
< statement 1 >;
END
ELSE
BEGIN
< statement 2 >;
END;
END
ELSE
BEGIN
< statement 2 >;
END;

sous la forme :

IF < expression 1 > AND < expression 2 > THEN

BEGIN
< statement 1 >;
END
ELSE
BEGIN
< statement 2 >;
END;

L’opérateur OR permet de simplifier l’écriture d’une série d’instructions IF imbriquées

de la forme suivante :

44 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 3. STRUCTURES DE CONTRÔLE

IF < expression 1 > THEN

BEGIN
<statement 1 >;
END
ELSE
BEGIN
IF < expression 2 > THEN
BEGIN
< statement 1 >;
END
ELSE
BEGIN
< statement 2 >;
END;
END;
sous la forme :
IF < expression 1 > OR < expression 2 > THEN
BEGIN
< statement 1 >;
END
ELSE
BEGIN
< statement 2 >;
END;

3.4 Les structures répétitives

3.4.1 Définition
Une structure répétitive permet d’exécuter une séquence d’instructions un certain
nombre de fois jusqu’à ce qu’une condition déterminée soit remplie ou non. La répétition
se fait par l’intermédiaire de boucles et d’itérations.

45 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 3. STRUCTURES DE CONTRÔLE

Une boucle consiste à parcourir ’une partie d’un programme un certain nombre de
fois. Une Itération est la répétition d’un même traitement plusieurs fois.
La même séquence d’instructions est réitérée plusieurs fois au cours d’une même
exécution
On distingue les boucles à bornes définies (POUR...FAIRE) et les boucles à bornes
non définies (TANTQUE...FAIRE et REPETE...JUSQU’A. Toute structure répétitive - est
composée de trois éléments :
– d’une initialisation d’un compteur ;
– d’une condition ;
– d’un bloc d’instructions.
Toute modification d’un quelconque de ces trois éléments nécessite un contrôle de
cohérence des deux autres.

3.4.2 Boucle à bornes définies (POUR...FAIRE)

Dans le cas d’une boucle à bornes définies, nous connaissons le nombre d’itérations à
effectuer, grâce aux valeurs des bornes minimum et maximum fournies dans la définition
de la boucle.
Un indice de boucle varie alors de la valeur minimum (initiale) jusqu’à la valeur
maximum (finale)
SYNTAXE :
En pseudo-code

POUR variable:=valeur_initiale A valeur_finale FAIRE

<séquence d’instruction>

En PASCAL

FOR variable := valeur_initiale TO valeur_finale DO

Bloc d’instructions;

Remarques
– la variable doit être de type scalaire (entier, énuméré, intervalle ou caractère) elle
ne peut pas être réelle

46 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 3. STRUCTURES DE CONTRÔLE

– si valeur_initiale > valeur_finale le FOR est ignoré

Exemple 35 program boucle_for;

var i:integer;
begin
for i:=1 to 5 do
writeln(’le carré de ’, i, ’ est :’, sqr(i));
writeln;
writeln(’FIN. A la prochaine...’);
end.

Il est possible d’imbriquer plusieurs boucles FOR :

For X1 := C1 to C2 do
Begin
...
For X2 := D1 to D2 do
Begin
...
End;
...
End;

Exemple 36 Table de multiplication

PROGRAM table_multiplication;
VAR
i, j : integer;
BEGIN
for i := 1 to 10 do
begin
for j := 1 to 10 do write (i*j : 3);
writeln;
end;
END.

47 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 3. STRUCTURES DE CONTRÔLE

3.4.3 Boucles à bornes non définies

Lorsque les bornes ne sont pas connues, il existe deux autres types de boucles :
– Boucle TANT QUE ... FAIRE ...
– Boucle REPETER ... JUSQU’A ...
Syntaxe de la boucle TANT QUE :
En pseudo-code

TANT QUE <condition> FAIRE

<séquence d’instructions>

En PASCAL

WHILE expression DO
Bloc d’instructions;

Remarques
– arrêt si expression est fausse
=⇒pas de boucle si faux au départ
– incrémentation gérée par le programmeur lui-même
=⇒pas d’augmentation automatique d’une variable (contrairement à la boucle
FOR)
– Les variables de l’expression expression doivent être initialisées avant le while,
pour que au premier passage expression puisse être évaluée.
Organigramme

Exemple 37 program boucle_while;

var
i:integer;
begin
i:=1;
while i <= 5 do
begin
writeln(’le carré de ’, i, ’ est :’, sqr(i));
i:=i+1; { incrémentation gérée par le programmeur }
end;
writeln;

48 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 3. STRUCTURES DE CONTRÔLE

Figure 3.5 – Organigramme de la structure TANTQUE... FAIRE

writeln(’FIN. A la prochaine...’);
end.

Syntaxe de la boucle REPETER :

En pseudo-code

REPETER
<séquence d’instructions>
JUSQU’A <condition>

En Pascal

REPEAT
Bloc d’instructions
UNTIL expression;

Remarques

La boucle s’effectue tant que l’expression est fausse, arrêt quand l’expression est
vraie. C’est le contraire de la boucle WHILE. Contrairement au WHILE, il y a au moins un
passage (1 boucle), même si l’expression est vraie ; De même que pour le WHILE, c’est
le programmeur qui gère l’incrémentation.
Organigramme

49 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 3. STRUCTURES DE CONTRÔLE

Figure 3.6 – Organigramme de la structure REPETER...JUSQUE

Exemple 38
program boucle_repeat;
var
i:integer;
begin
repeat
writeln(’le carré de ’, i, ’ est :’, sqr(i));
i:=i+1; { incrémentation gérée par le programmeur }
until i>5;
writeln;
writeln(’FIN. A la prochaine...’);
end.

Exemple 39 exécution répétitive d’un programme

Variables :
a,b : réel; (*opérandes *)
p : réel; (*résultat du produit *)
c : caractère; (*réponse de l’utilisateur *)
Début
Répéter
Ecrire (’Saisir le nombre a’);
Lire (a);

50 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 3. STRUCTURES DE CONTRÔLE

Ecrire (’Saisir le nombre b’);

Lire (b);
p:=a*b;
Ecrire (p);
Ecrire (’encore un calcul ? Non touche N ; Oui autre touche’);
Lire (c);
Jusqu’à c = ’N’;
Fin.

NB : Faire attention aux conditions initiales, aux conditions d’arrêt et à l’incrémentation

sinon la boucle risque d’être infinie. Les deux boucles peuvent être choisies indifféremment.
Cependant, l’une est le contraire de l’autre, au niveau de la condition d’arrêt :

TANTQUE condition1 FAIRE

<Bloc d’instructions>

⇐⇒

REPETER
<Bloc d’instructions>
JUSQU’A non (condition1)

– Tant que condition1 est vraie, faire bloc d’instructions...

– Répéter bloc d’instructions, jusqu’à ce que condition1 ne soit plus vraie
Dans ce cas, la condition d’arrêt de la boucle TANTQUE est l’opposée de la condition
d’arrêt de la boucle REPETER.

Exemple 40
TANTQUE (i<>10) FAIRE
i:= i+1 {on fait varier i jusqu’à 10}

est équivalent à :

REPETER
i:=i+1
JUSQU’A (i=10)

51 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 3. STRUCTURES DE CONTRÔLE

Il est toujours équivalent d’utiliser une boucle TANTQUE ou une boucle REPETER. Ce-
pendant, il existe une petite différence entre les deux boucles : Dans le cas d’une boucle
REPETER... JUSQU’A, le bloc d’instructions est effectué au moins une fois, ce qui n’est
pas forcément vrai pour une boucle TANTQUE. En effet, pour ce dernier type de boucle, si
la condition est fausse dès le départ, le bloc d’instructions ne sera pas du tout exécuté.
En revanche, avec une boucle REPETER ... JUSQU’A, si la condition est fausse dès le
départ, le bloc d’instructions sera quand même exécuté une fois.
Remarque :
Les boucles REPETER et TANTQUE peuvent être utilisées même si les bornes sont définies.
Dans ce cas, il est bien entendu préférable d’utiliser une boucle POUR (vue précédemment).

3.4.4 Exemple comparatif

Nous allons à présent traiter le même exemple, avec trois boucles différentes. Il s’agit
de reconstruire l’opération de multiplication, en effectuant des sommes successives. Soit
à effectuer le produit des entiers naturels a et b (distincts de 0).
Données : a multiplicande, b multiplicateur
Résultat : P produit Méthode : ajouter b fois le multiplicande

Exemple 41 Forme 1 avec POUR

Algorithme Avec_Pour;
var a,b,i,P:entier;
Debut
Ecrire(’Donner a et b’);
Lire(a,b);
P:=0;
Pour i:=1 à b Faire
P:=P+a;
Ecrire(’Le produit est’,P);
Fin.

Exemple 42 Forme 2 avec TANT QUE

Algorithme Avec_TANTQUE;
var a,b,i,P:entier;

52 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 3. STRUCTURES DE CONTRÔLE

Debut
Ecrire(’Donner a et b’);
Lire(a,b);
P:=0;i:=1;
TantQue (i<=b) Faire
Debut
P:=P+a;
i:=1+1;
Fin;
Ecrire(’Le produit est’,P);
Fin.

Exemple 43 Forme 3 avec REPETER

Algorithme Avec_REPETER;
var a,b,i,P:entier;
Debut
Ecrire(’Donner a et b’);
Lire(a,b);
P:=0;i:=1;
Repeter
P:=P+a;
i:=1+1;
Jusque (i>b);
Ecrire(’Le produit est’,P);
Fin.

Nous pouvons modifier les algorithmes précédents en y rajoutant des contrôles de

saisie sur les valeurs de a et de b, puisqu’elles doivent être strictement positives. Le
controle peut être fait avec la boucle TANTQUE ou la boucle REPETER. Pour la forme 1
nous avons :

Exemple 44
Algorithme Avec_REPETER_Controle_REPETER;
var a,b,i,P:entier;
Debut

53 Dr O. THIARE/UGB-UFR SAT
 CHAPITRE 3. STRUCTURES DE CONTRÔLE

Repeter
Ecrire(’Donner a et b’);
Lire(a,b);
Jusque (a>0) ET (b>0);
P:=0;i:=1;
Repeter
P:=P+a;
i:=1+1;
Jusque (i>b);
Ecrire(’Le produit est’,P);
Fin.

Exemple 45
Algorithme Avec_REPETER_Controle_TANTQUE;
var a,b,i,P:entier;
Debut
Ecrire(’Donner a et b’);
Lire(a,b);
TantQue (a<=0) OU (b<=0) Faire
Debut
Ecrire(’Donner a et b’);
Lire(a,b);
Fin
P:=0;i:=1;
Repeter
P:=P+a;
i:=1+1;
Jusque (i>b);
Ecrire(’Le produit est’,P);
Fin.

54 Dr O. THIARE/UGB-UFR SAT