1. Bruno Delb http://www.brunodelb.com Date : 14/04/2001
Le langage Pascal
Sommaire
PRÉSENTATION.......................................................................................................4
LE PROGRAMME SOURCE, LE PROGRAMME COMPILÉ.................................................................4
LES SPÉCIFICITÉS DE TURBO PASCAL 3.0...........................................................................4
L’édition, la compilation........................................................................................4
Les touches de fonction F7, F8..............................................................................4
La séquence ce touches Ctrl-K, C...........................................................................4
La séquence de touches Ctrl-K, W, Ctrl-K, R............................................................4
Les directives......................................................................................................5
LES ÉTIQUETTES ET LE BRANCHEMENT DIRECT [LABEL, GOTO]................................................5
LA SORTIE [EXIT, HALT].............................................................................................5
HISTORIQUE...........................................................................................................7
LA NAISSANCE DE PASCAL..............................................................................................7
L’ÉVOLUTION DE PASCAL................................................................................................7
LE P CODE................................................................................................................7
LES BASES...............................................................................................................9
INTRODUCTION...........................................................................................................9
Les identificateurs................................................................................................9
Les règles...........................................................................................................9
LA STRUCTURE DU PROGRAMME........................................................................................9
Indiquer le nom du programme [Program]..............................................................9
Définir un bloc [Begin, End]..................................................................................9
Insérer un commentaire [(* *) { }].......................................................................9
LE CONTRÔLE DE L’ÉCRAN............................................................................................10
Afficher un texte [Write, WriteLn]........................................................................10
Positionner le curseur [GotoXY.............................................................................10
Contrôler l’affichage [ClrScr, Delay, DelLine, InsLine, CtrEol]..................................10
LA PRÉSENTATION......................................................................................................10
Le débordement de ligne.....................................................................................10
Les conseils.......................................................................................................10
LA DÉCLARATION, L’ASSIGNATION......................................................................13
LES VARIABLES.........................................................................................................13
Nommer une variable.........................................................................................13
Evaluer une variable...........................................................................................13
DÉCLARER UNE VARIABLE [VAR].....................................................................................13
AFFECTER UNE VALEUR À UNE VARIABLE............................................................................14
Affecter une expression à une variable [:=]..........................................................14
Affecter une valeur lue au clavier à une variable [Read].........................................14
LES OPÉRATEURS..................................................................................................15
INTRODUCTION.........................................................................................................15
LES OPÉRATEURS ARITHMÉTIQUES [*, /, DIV, MOD, +, -].....................................................15
LES OPÉRATEURS DE COMPARAISON [<, >, =, <>, <=, >=]...............................................15
LES FONCTIONS ARITHMÉTIQUES [ABS, COS, EXP, FRAC, ...].................................................16
REMARQUES.............................................................................................................16
L’ordre des priorités............................................................................................16
Les erreurs d'approximation................................................................................17
1

2. Bruno Delb http://www.brunodelb.com Date : 14/04/2001
Le langage Pascal
LES RÉPÉTITIONS ................................................................................................19
INTRODUCTION.........................................................................................................19
LA BOUCLE WHILE.....................................................................................................19
Algorithme de While...Wend................................................................................19
LA BOUCLE REPEAT....................................................................................................20
LA BOUCLE FOR........................................................................................................20
Les paramètres To et DownTo..............................................................................20
La fréquence de Begin .. End dans For..................................................................20
Algorithme de For...............................................................................................21
REMARQUES.............................................................................................................21
La boucle d'attente.............................................................................................21
Utiliser For avec précaution.................................................................................22
LES CONDITIONS..................................................................................................23
DÉFINITION.............................................................................................................23
LE DOMAINE DE DÉFINITION..........................................................................................23
TESTER UNE EXPRESSION EN FONCTION DE PLUSIEURS VALEURS [CASE].....................................23
Remarques........................................................................................................24
Combiner plusieurs constantes............................................................................24
LES CONDITIONS [IF, THEN, ELSE].................................................................................24
REMARQUES.............................................................................................................25
Une erreur classique...........................................................................................25
Les tests en cascade...........................................................................................25
LES PROCÉDURES ET LES FONCTIONS...................................................................27
LE BLOC D'INSTRUCTIONS.............................................................................................27
LES TYPES DE VARIABLE...............................................................................................27
La variable globale.............................................................................................27
La variable locale...............................................................................................27
LA PROCÉDURE [PROCEDURE]........................................................................................27
Appeler une procédure à partir d'une autre procédure............................................27
Les méthodes d'appel d'une procédure.................................................................28
LES FONCTIONS........................................................................................................28
Appeler une fonction...........................................................................................28
Affecter la valeur d'une fonction..........................................................................28
La définition n'intervenant qu'après appel.............................................................29
REMARQUES.............................................................................................................29
La programmation modulaire...............................................................................29
Différencier variable globale et variable locale.......................................................29
Les paramètres d'entrée, de sortie, mixte.............................................................29
L’effet de bord...................................................................................................29
LES TYPES DE STRUCTURES..................................................................................30
LES CONSTANTES......................................................................................................30
Modifier une constante [=]..................................................................................30
Déclarer une constante [Const]...........................................................................30
Utiliser une expression dans la déclaration............................................................30
LES TYPES SCALAIRES.................................................................................................30
Déclarer un type scalaire.....................................................................................30
Le type ordinal...................................................................................................30
LES TABLEAUX [ARRAY]...............................................................................................31
Accéder à un élément.........................................................................................31
Utiliser des tableaux multidimensionel..................................................................31
Le type sous-porté.............................................................................................31
L’ENSEMBLE.............................................................................................................31
Effectuer des opérations sur un ensemble.............................................................32
2

3. Bruno Delb http://www.brunodelb.com Date : 14/04/2001
Le langage Pascal
Délimiter des domaines de validité.......................................................................32
Utiliser les constantes pour le débogage...............................................................32
3

4. Bruno Delb http://www.brunodelb.com Date : 14/04/2001
Le langage Pascal
Présentation
Le programme source, le programme compilé
Un programme écrit en Pascal est appelé programme source. Il n'est pas
compréhensible directement par l'ordinateur. Pour qu'il puisse être
exécuté, il faut procéder à une autre étape : la compilation. C'est là tout le
rôle de Turbo Pascal. Le résultat est un programme en langage machine.
Les spécificités de Turbo Pascal 3.0
L’édition, la compilation
Turbo Pascal fournit un petit éditeur de texte. Pour y accéder, il suffit de
presser E lorsque vous êtes au menu. Pour compiler un programme
source, pressez C. Il sera compilé en mémoire. Si vous voulez le compiler
en créant un fichier COM, pressez O (Options), puis C (Com-File), Q
(Quitter le menu des options) et enfin C (Compile). Pour l'exécuter il ne
vous restera plus qu'à quitter Turbo Pascal et à lancer le fichier COM.
Les touches de fonction F7, F8
Les touches du bloc curseur remplissent les fonctions usuelles d'édition.
Les touches de fonction F7 et F8 délimitent respectivement le début et la
fin d'un bloc.
La séquence ce touches Ctrl-K, C
Les touches Ctrl-K puis C recopie le bloc sélectionné par F7 et F8 à l'endroit
positionné par le curseur. Les touches Ctrl-K puis Y effacent le contenu de
ce bloc.
La séquence de touches Ctrl-K, W, Ctrl-K, R
Les touches Ctrl-K puis W permettent d'enregistrer sur disque le bloc
sélectionné, tandis que Ctrl-K puis R effectue le contraire : la lecture du
bloc.
4

5. Bruno Delb http://www.brunodelb.com Date : 14/04/2001
Le langage Pascal
Les directives
Vous pouvez fournir une directive de compilation à Turbo Pascal :
"{$lettre}", lettre désignant une lettre ou un groupe de lettres d'une ou de
directives de compilation.
Voici une liste de directives de Turbo Pascal :
Directive Description
{$I+} Contrôle des Entrées - Sorties autorisé (par défaut)
{$I-} Contrôle des Entrées - Sorties interdit
{$V+} Test de la longueur d'une chaîne autorisé (par
défaut)
{$V-} Test de la longueur d’une chaîne interdit
{$R+} Contrôle de l'index de champ autorisé
{$R-} Contrôle de l’index de champ interdit (par défaut)
Les étiquettes et le branchement direct [LABEL, GOTO]
L’utilisation de Label et de Goto est une mauvaises habitudes.
Turbo Pascal admet les instructions :
Label NOM
... ...
Goto NOM
L'intérêt d'une telle instruction est visible par exemple dans le cas suivant :
Si erreur Alors
Faire
Message d'erreur
Aller à la fin du programme
FinFaire
Corps du programme
La sortie [EXIT, HALT]
Deux autres instructions sont aussi utilisées :
Exit quitte le bloc programme courant
Halt quitte le programme
5

6. Bruno Delb http://www.brunodelb.com Date : 14/04/2001
Le langage Pascal
Historique
La naissance de Pascal
Pascal est un langage de programmation créé en 1963 par le Professeur
Niklaus Wirth de l'Eidgenossisch Technische Hochshcule de Zurich. Il a pris
naissance après constatation de Dahl et de Dijkstra que 50 % du coût de
l'élaboration d'un logiciel incombait à la maintenance, contre 10 %
seulement pour la première écriture du programme. Ceci explique la
naissance d'un langage de science exacte, et non pas artistique.
Wirth s'est inspiré de l'Algol, et a doté Pascal d'une certaine cohérence (il
en est le seul auteur, au contraire de Ada), d'une simplicité, et d'une
efficacité.
L’évolution de Pascal
Plusieurs versions ont été dès lors créées :
• première version à Zurich sur un CDC 6000
• implantation sur micro-ordinateurs effectuée par Kenneth
BOWLES de l'Université of California at San Diego (UCSD) :
version optimisée (overlays, librairies, utilisation statistiques pour
la fréquence des instructions, ...),
• beaucoup d'autres : TINY PASCAL, PASCAL MT+, PASCAL JRT, ...
• et maintenant le phénomène TURBO PASCAL.
Le P Code
Dès l'origine apparut l'idée suivante =
• le programme source est transformé en P Code, véritable
langage indépendant de la machine (90 % du travail total à
fournir).
• le P Code, comprit par une machine virtuelle (P Machine) est
alors transformé en langage machine sur la machine spécifique
(10 % du travail total à fournir).
7

7. Bruno Delb http://www.brunodelb.com Date : 14/04/2001
Le langage Pascal
Les bases
Introduction
La syntaxe est un ensemble de règles d'utilisation des mots, nombres et
ponctuation.
Les identificateurs
Les noms, ou identificateurs, sont fournis dans les procédures, fonctions et
variables. Un identificateur reconnait au maximum huit caractères.
Toutefois, vous pouvez en utiliser plus, à condition cependant de ne pas
oublier que seuls les huit premiers seront reconnus par le langage.
Les règles
Il y a trois règles pour les identificateurs :
• ils doivent tous commencer par une lettre
• les caractères suivant le premier doivent être soit une lettre soit
un chiffre, et rien d'autre
• les mots réservés ne peuvent être utilisés comme noms
d'identificateurs.
La structure du programme
Indiquer le nom du programme [Program]
Un programme doit commencer par le mot réservé PROGRAM suivi du
caractère ; (point virgule).
Définir un bloc [Begin, End]
Puis il faut fournir le jeu d'instruction dans le « Block Statement », qui
comprend à la fois BEGIN et END. A l'unique exception « END. », tous les
ordres du programme doit finir par un point-virgule.
Enfin, tous les ordres du programme principal sont décalés de trois
espaces par rapport à BEGIN.
Insérer un commentaire [(* *) { }]
Des commentaires peuvent être ajoutés n'importe où dans un programme.
Ils sont introduits par (* et terminés par *). Ils seront ignorés aussi bien
lors de l'exécution du programme que lors de la compilation du source.
9

8. Bruno Delb http://www.brunodelb.com Date : 14/04/2001
Le langage Pascal
Le contrôle de l’écran
Afficher un texte [Write, WriteLn]
Les ordres WRITE et WRITELN affichent des messages à l'écran. WRITE
permet d'afficher plusieurs mots, tandis qu'à chaque exécution de
WRITELN, un saut de ligne et un retour chariot sont opérés.
Positionner le curseur [GotoXY
On peut également déplacer le curseur sur l'écran par emploi de l'ordre
GOTOXY. Le coin supérieur gauche correspond au point de coordonnées
0,0. Le point de coordonnées 1,1 correspond au point situé à l'intersection
de la deuxième colonne et de la deuxième ligne.
Contrôler l’affichage [ClrScr, Delay, DelLine, InsLine, CtrEol]
De plus, Pascal met à votre disposition un certain nombre d'instructions
très utiles :
Instruction Description
ClrScr Efface l'écran et place le curseur en haut à gauche de
l'écran
Delay Attend Temps millisecondes
DelLine Efface la ligne contenant le curseur
InsLine Insère la ligne contenant le curseur
CtrEol Efface de la position du curseur jusqu'à la fin de la ligne
La présentation
Le débordement de ligne
Dans l'éventualité où la liste des paramètres ne tienne pas sur une ligne,
arrangez-vous, si possible, de faire aligner les suivants avec les
précédents.
Les deux ordres WRITELN (liste de données); et WRITE (liste de données); WRITELN;
sont équivalents.
Lorsqu'une assignation d'une expression à une variable est faite et qu'elle
ne tient pas sur une ligne, la suite est inscrite juste sous la partie
précédente de l'expression. Pour READ et READLN, c'est la même chose
que pour WRITE et WRITELN.
Les conseils
Les abréviations
Premier conseil : dans la limite du possible, évitez de dépasser huit
caractères de longueur pour les noms d'identificateurs, afin d'éviter le
10

9. Bruno Delb http://www.brunodelb.com Date : 14/04/2001
Le langage Pascal
conflit de nomrs dû à d'éventuelles duplication. Essayez donc d'utiliser des
abréviations standards, comme lorsque vous prenez des notes lors d'une
conférence.
Dans le même ordre d'idées, évitez de trop abréger les noms
d'identificateurs puisqu'il y a alors risque de créer des noms qui se
ressemblent, source d'erreur.
Les commentaires
Deuxième conseil : afin de faciliter la compréhension du programme,
placez des commentaires entre les BEGIN...END.
Un commentaire placé au début renseigne sur l'auteur, la date d'écriture,
le numéro de la version, ...
Les paramètres
Troisième conseil : les paramètres (ce qui est situé entre parenthèses),
devraient être séparés par une virgule (,), suivi d'un espace ( ), le tout
pour faciliter la relecture du programme. De même, il serait judicieux de
placer un espace juste aprsès la parenthèse d'ouverture.
11

10. Bruno Delb http://www.brunodelb.com Date : 14/04/2001
Le langage Pascal
La déclaration, l’assignation
Les variables
Les variables sont des emplacements dans la mémoire de l'ordinateur.
Elles portent chacunes un nom. Vous devez déclarer lesquelles seront
utilisées, ainsi que les genres de valeurs qu'elles prendront.
Nommer une variable
Chaque nom de variable est décalé de trois espaces de VAR. A sa droite,
doit figurer un commentaire explicitant son utilisation. Chaque type de
variable est décalé de trois espaces, suivant la syntaxe « : type; ». Pour ce
qui est des attributs de longueur (entre accolades), le même traitement est
fait que pour les parenthèses.
Evaluer une variable
Le résultat d'une opération arithmétique sera réel si l'un au moins des
facteurs est réel.
Déclarer une variable [Var]
VAR est le mot réservé qui indique à l'ordinateur que vous allez utiliser des
variables. Leur nom et leur champ de valeur sera indiqué juste après VAR.
La déclaration VAR doit être décalée de trois espaces, et une ligne doit être
sautée à la fois avant l'ordre VAR et après la dernière variable déclarée.
L'ordre VAR reconnait les types suivants.
Type Description
Integer Nombre entier compris entre 32767 et - 32768
Byte Sous ensemble de INTEGER, compris entre 0 et 255
String Chaîne de caractères d'au plus 80 caractères s'il figure [nombre] juste après STRING,
alors la chaîne est limitée au nombre indiqué entre parenthèse (limite supérieure fixée
à 256)
Char Un seul caractère
Boolean Contient la valeur TRUE (vrai) ou FALSE (faux)
Real Nombre réel (souvent exprimé en notation scientifique)
13

11. Bruno Delb http://www.brunodelb.com Date : 14/04/2001
Le langage Pascal
Affecter une valeur à une variable
Affecter une expression à une variable [:=]
« Assignation directe » range une valeur directement dans une variable. Le
symbole « := » est alors placé entre le nom de la variable (à gauche) et la
valeur (à droite).
Le schéma d'une affectation directe est le suivant :
Variable_Réceptrice := Expression_Source;
Une expression étant une suite hiérarchisée d'opérations élémentaires.
Notez que le résultat d'une opération arithmétique est réel si l'un au moins
des facteurs est réel.
Affecter une valeur lue au clavier à une variable [Read]
L'ordre READ permet à l'ordinateur de capter une donnée en cours
d'exécution du programme. Utilisez READ si un « enter » (ou return) n'est
pas obligatoire à la fin de la saisie. Sinon, employée READLN.
Les variables BOOLEAN ne peuvent recevoir de valeur qu'en assignation
directe. Avec les variables CHAR, READ est utilisé, mais la plupart du
temps, ce sera READLN, puis qu'un return est le plus souvent demandé.
14

12. Bruno Delb http://www.brunodelb.com Date : 14/04/2001
Le langage Pascal
Les opérateurs
Introduction
Les opérateurs arithmétiques sont des symboles qiu indiquent à
l'ordinateur d'effectuer certaines opérations mathématiques. On peut citer
l'addition, la division, ... Ils sont utilisés avec des variables de type entier
(INTEGER ou LONG INTEGER) ou réel (REAL).
Les opérateurs arithmétiques et de comparaison sont précédés et suivis
d'un espace.
De plus, les expressions logiques (utilisant la logique booléenne) contenant
plusieurs opérateurs doivent utiliser des parenthèses.
Les opérateurs arithmétiques [*, /, Div, Mod, +, -]
Ces opérateurs standards sont :
Opérateur Description
* Multiplication
/ Division
DIV Division d'entiers
MOD Module (le reste, nombre entier, de la division de X par Y)
+ Addition
- Soustraction
Remarque : les résultats, sauf exception indiquée, sont des nombres réels.
Les opérateurs de comparaison [<, >, =, <>, <=, >=]
Voici maintenant une liste des opérateurs de comparaison :
Opérateur Description
< plus petit que
> plus grand que
= égal à (différent de :=)
<> différent
>= plus grand ou égal à (dans cet ordre !)
<= plus petit ou égal à (dans cet ordre !)
Cas particulier : les chaînes de caractères.
15

13. Bruno Delb http://www.brunodelb.com Date : 14/04/2001
Le langage Pascal
Note : les comparaisons sont effectuées de la même manière pour les
chaînes de caractères que pour les nombres. Un « A » est « plus petit »
qu'un « B » ! (voir les codes ASCII pour plus de précisions).
Les fonctions arithmétiques [Abs, Cos, Exp, Frac, ...]
Voici d'autres fonctions arithmétiques disponibles :
Fonction Description
Abs (Nombre) Renvoit la partie absolue de nombre
ArcTan (Nombre) Renvoit l'arc-tangente de nombre
Cos (Nombre) Renvoit le cosinus de nombre
Exp (Nombre) Renvoit l'exponentielle de nombre
Frac (Nombre) Renvoit la partie décimale de nombre
Int (Nombre) Renvoit la partie entière de nombre (en réel)
Ln (Nombre) Renvoit le logarithme népérien de nombre
Pred (Nombre) Equivaut à Nombre := Nombre - 1
Sin (Nombre) Renvoit le cosinus de nombre
Sqr (Nombre) Renvoit le carré de nombre
Sqrt (Nombre) Renvoit la racine carrée de nombre
Round (Nombre) Renvoit l'arrondi à l'entier le plus proche de
nombre (en entier)
Trunc (Nombre) Renvoit la partie entière de nombre (en entier)
Random Renvoit un nombre aléatoire compris entre 0 et 1
Random (Nombre) Renvoit un nombre aléatoire compris entre 0 et
nombre
Succ (Nombre) Equivaut à Nombre := Nombre + 1
Remarques
L’ordre des priorités
Après avoir tenu compte des priorités des opérateurs, l'ordinateur effectue
les calculs de gauche à droite.
Voici l'ordre de priorité des opérateurs :
• d'abord les multiplications et les divisions (*, /, DIV, MOD)
• ensuite les additions et les soustractions (+, -)
Toutefois, vous pouvez indiquer à l'ordinateur d'effectuer un groupe
d'opérations avant les autres (quelque soit leur degré de priorité). Ce
groupe est délimité par des parenthèses, de la même manière qu'en
mathématiques.
Note : pour effectuer les calculs, vous pouvez intégrer des opérateurs dans
des expressions d'assignation de variables.
16

14. Bruno Delb http://www.brunodelb.com Date : 14/04/2001
Le langage Pascal
Les erreurs d'approximation
Attention, rappelez-vous que l'ensemble mathématiques de la machine
n'est pas continu, à cause du manque de précision de l'ordinateur. Il peut
donc arriver que certains résultats semblent présenter des erreurs.
17

15. Bruno Delb http://www.brunodelb.com Date : 14/04/2001
Le langage Pascal
Les répétitions
Introduction
Un des grands intérêts de l'ordinateur est la possibilité de répéter de
nombreuses fois une même tâche. Les instructions de boucle ont donc été
créés. Ils permettent donc de faire répéter une séquence d'instructions en
un minimum d'instructions.
Voyons While et Repeat. Ils permettent la répétition d'une série d'ordres un
certain nombre de fois. Ce nombre n'est pas pré-défini, puisque la boucle
est effectuée tant que la condition indiquée est remplie.
La boucle While
La syntaxe de la boucle « while » est :
WHILE expression DO ordre;
Algorithme de While...Wend
J := a
Tant que <condition> et (J <= b) faire
Commencer
(ordres)
J = J + pas (équation de définition)
Fin
Fin de tant que
La condition d'arrêt est :
• si p > 0 : (j > b) et (condition fausse)
• si p < 0 : (j < b) et (condition fausse)
ou encore, cas particulier :
Tant que <condition> faire
Commencer
(ordres)
Fin
Si une seule instruction, on peut écrire Tant que "<condition> faire
<ordre>"
19

16. Bruno Delb http://www.brunodelb.com Date : 14/04/2001
Le langage Pascal
La boucle Repeat
Et celle de la boucle « repeat » : "REPEAT ordre UNTIL expression;" où
expression a un rôle de valeur booléenne.
L'algorithme de Repeat .. Until est le suivant :
Faire varier J de n à b par pas de p tant que <condition>
Pour chaque J
(ordres)
FinFaire
La boucle For
Voyons maintenant la boucle FOR. Sa syntaxe est "FOR variable:=
expression1 TO expression2 DO ordre;" (parcours séquentiel en sens
croissant) ou "FOR variable:= expression1 DOWNTO expression2 DO
ordre;" (parcours séquentiel en sens décroissant).
Notez que la variable et les expressions doivent être du même type. De
plus, le nombre de fois que la boucle est exécuté est égal à la différence
entre les expressions plus un. La variable est utilisée comme compteur, ou
variable de contrôle, et contient toutes les valeurs entières comprises entre
expression1 et expression2.
Les paramètres To et DownTo
TO dit à l'ordinateur d'incrémenter le compteur. DOWNTO fait l'opposé : il
y a décrémentation. Si avec TO, expression1 est inférieur à expression2,
(ou le contraire avec DOWNTO), alors la boucle n'est pas du tout exécutée.
La fréquence de Begin .. End dans For
Les ordres entre BEGIN et END peuvent être aussi nombreux que vous le
voulez. Toutefois, vous ne pourrez pas utiliser la variable de nom celui du
compteur, sauf action précise sur le compteur recherchée. De plus, à la
sortie de la boucle, la variable de contrôle doit être considérée comme
ayant une valeur non définie. En ce sens, que sa valeur aura été altérée
par la boucle.
20

17. Bruno Delb http://www.brunodelb.com Date : 14/04/2001
Le langage Pascal
Algorithme de For
Pour mieux comprendre les boucles de parcours conditionnelles, étudiez les
deux algorithmes suivants :
Algorithme de FOR...NEXT :
(initialisation induites)
Faire varier J de a à b par pas de p tant que <condition>
Pour chaque J
(ordres)
FinFaire
(opérations finales)
Il y a deux critères d'arrêt, qui constituent ainsi une formulation d'une
limite absolument nécessaire.
• si p>0, ils sont J>b et condition fausse
• si p<0, ils sont J<b et condition fausse
Naturellement, la condition d'arrêt doit être réalisable en un nombre fini
d'itérations.
Remarques
La différence entre WHILE et REPEAT est que REPEAT vérifie l'expression à
la fin de la boucle, alors que WHILE le fait, mais au début. Donc REPEAT
est exécuté au moins une fois, alors que pour WHILE, ce n'est pas
obligatoire.
REPEAT implique la présence de BEGIN...END. Et même, si vous
l'ommettez, l'ordinateur en place une, mais « invisible ».
Mêmes conseils à appliquer que pour les autres chapitres : décaler de trois
espaces les ordres situés dans les boucles fermées par FOR, WHILE ou
REPEAT. Rappelez-vous cependant que la structure BEGIN..END n'est pas
nécessaire dans une boucle REPEAT.
La boucle d'attente
En plaçant un point-virgule (;) juste après DO, vous générez une boucle
d'attente, c'est-à-dire qu'un certain laps de temps s'écoule sans qu'aucune
instruction ne soit exécutée.
21

18. Bruno Delb http://www.brunodelb.com Date : 14/04/2001
Le langage Pascal
Utiliser For avec précaution
De plus, prenez garde à ceci. La structure :
FOR I := 1 TO 10 DO
FOR J := 1 TO 10 DO
BEGIN
END;
BEGIN
END;
est valide. Mais la structure suivante est invalide :
FOR I := 1 TO 10 DO
BEGIN
FOR J := 1 TO 10 DO
END;
BEGIN
END;
22

19. Bruno Delb http://www.brunodelb.com Date : 14/04/2001
Le langage Pascal
Les conditions
Définition
Les ordres de condition constituent le coeur de tout programme effectuant
une « décision ». Grâce à celles-ci, l'ordinateur devient très puissant.
Ces instructions sont :
IF expression THEN ordre;
ou
IF expression THEN ordre
ELSE ordre;
où expression est de type booléen, et ordre est soit un ordre seul, ou alors
une structure du type BEGIN..END.
Dans le premier cas, si (IF) l'expression est vraie, alors (THEN) exécute les
ordre(s) suivants.
Dans le second cas, si (IF) l'expression est vraie, alors (THEN) exécute les
ordre(s) suivants sinon (ELSE) exécute ces autres ordres.
IF..THEN..ELSE constitue un irdre en lui-même et doit donc satisfaire à la «
règle du point-virgule ».
Le domaine de définition
Un algorithme est conçu pour un groupe de données (ou paramètres) dont
le domaine de validité présente souvent des restrictions par rapport à leur
ensemble de définition.
Tester une expression en fonction de plusieurs valeurs [Case]
Il existe un autre genre d'ordre conditionnel : CASE. La syntaxe est :
CASE expression OF
constant: ordre;
constant: ordre;
... ...
constant: ordre;
END;
L'instruction CASE permet de choisir un traitement, et un au plus, parmi
plusieurs, en fonction d'un critère. Si aucune condition n'est remplie, il y a
erreur. Si une condition est remplie, alors seul le traitement correspondant
est exécuté, puis le programme reprend à la suite.
23

20. Bruno Delb http://www.brunodelb.com Date : 14/04/2001
Le langage Pascal
Remarques
L'expression et les constantes doivent évidement être du même type ! De
plus, la constante ne peut être une variable.
Notez que là aussi, comme pour la boucle REPEAT, cette instruction a un
BEGIN induit, mais pas un END cette fois. De plus, vous n'avez pas le droit
de placer une BEGIN.
Combiner plusieurs constantes
Au cas où vous voulez combiner plusieurs constantes, en ce sens que si
expression est égal à constante1 ou à constante2, ... vous devez placer les
différentes constantes les unes après les autres, séparées chacunes d'une
virgule. Nous vous conseillons toutefois de placer la première constante sur
la première ligne, la seconde sur la seconde, ...
Les constantes sont décalées de deux ou trois espaces. Les commentaires
seront plutôt placés à la fin des instructions CASE et IF.
Les conditions [If, Then, Else]
Toujours les conseils pour facilité la relecture et la compréhension du
programme.
Tout d'abord, les ordres utilisés dans l'ordre IF doivent être décalés de 2
ou 3 espaces. Si vous utilisez un ELSE, il doit venir se placer sous le IF, et
même chose pour ses ordres que pour IF.
Notez aussi que raccorder ELSE à l'ordre IF peut aider à identifier
rapidement une instruction de branchement.
Le schéma d'un test est :
SI hypothèse satisfaite
ALORS (* donnée correcte *) lancer l'algorithme
SINON erreur de donnée
Ainsi, si la condition est remplie alors le premier traitement, et lui seul, est
lancé (lancer l'algorithme). Si elle est fausse, alors seul le second
traitement, et lui seul, est lancé (erreur de donnée).
24

21. Bruno Delb http://www.brunodelb.com Date : 14/04/2001
Le langage Pascal
Remarques
Une erreur classique
Attention l'erreur classique de placer un point-virgule (;) devant le ELSE !
Un IF est suivi d'un point-virgule si et seulement s'il précède une autre
instruction dans le même groupe BEGIN.
Les tests en cascade
Remarquez l'intérêt des tests en cascade : il permettent d'améliorer les
performances d'un programme, en y effectuant le minimum indispensable
de tests.
25

22. Bruno Delb http://www.brunodelb.com Date : 14/04/2001
Le langage Pascal
Les procédures et les fonctions
Le bloc d'instructions
Chaque bloc en Pascal est identifié par un nom. Immédiatement après ce
nom, se trouve le bloc lui-même, délimité par BEGIN..END.
La syntaxe est la suivante :
Nom (entrée : x, y, z; sortie : a, b);
a et b constituent les paramètres formels
x, y et z constituent les paramètres effectifs
Les types de variable
La variable globale
Une variable déclarée en début de programme est dite variable globale,
puis qu'elle sera utilisée partout dans le programme.
La variable locale
Si une variable est déclarée à l'intérieur d'un bloc autre que le bloc
principal, la variable est appelée variable locale. Celle-ci ne peut être
accédée qu'à partir du bloc où elle a été déclarée.
La procédure [Procedure]
Elle est similaire au programme (PROGRAM). Toutefois, il existe deux
différences :
• le mot réservé PROCEDURE est utilisé à la place de PROGRAM
• le END est suivi d'un point-virgule à la place d'un point.
L'objectif majeur d'une procédure est d'effectuer une tâche spécifique.
Cette tâche, ou routine, est généralement exécutée plus d'une fois, et
souvent appelée de divers endroits du programme.
Appeler une procédure à partir d'une autre procédure
Attention aussi à une chose : une procédure B peut appeler une procédure
A à la seule condition que la définition de A figure avant celle de B. De
plus, il doit alors y avoir correspondance absolue entre ces paramètres
(même nombre, même type). De même, une constante, une variable, une
procédure, ou une étiquette déclarée à l'intérieur d'une procédure n'est
accessible qu'à partir de cette procédure.
27

23. Bruno Delb http://www.brunodelb.com Date : 14/04/2001
Le langage Pascal
Les méthodes d'appel d'une procédure
Il existe deux méthode pour appeler une procédure :
L’appel par valeur (paramètres récepteurs)
Une valeur est passée et utilisée localement dans la procédure.
Les variables encadrées de parenthèses sont locales à la procédure et
nommées paramètres formels. La déclaration de ces paramètres formels
se fait de façon similaire à celle faite avec VAR.
La liste de paramètres associée à l'ordre d'appelle d'une procédure
constitue les paramètres actuels. Les paramètres formels et ceux actuels
doivent se correspondre en type, en ordre, et en nombre.
L’appel par adresse (ou paramètres variables ou vrais)
Les paramètres variables permettent aux procédures d'utiliser et de
retourner une valeur dans le paramètres actuel.
Différences entre les deux méthodes
Trois grandes différences marquent les deux méthodes :
• les paramètres variables permettent le retour d'information d'une
procédure par utilisation de la liste de paramètres, pas l'autre
méthode.
• un paramètre actuel DOIT être une variable lorsque vous utilisez
des paramètres variable. Une valeur littéralle peut être passée à
une valeur de paramètre de type STRING, mais pas à un
paramètre variable.
• vous définissez une paramètre variable dans une liste de
paramètres en plaçant un préfixe VAR.
Les fonctions
Une différence entre une fonction et une procédure est le changement du
mot réservé utilisé.
Après le nom d'une fonction, il faut spécifier le type de valeur que la
fonction retournera. Cette valeur doit être de type simple (INTEGER,
BOOLEAN, REAL, ou CHAR).
Appeler une fonction
Une autre différence réside dans l'appel d'une fonction.
En effet, il suffit d'utiliser son nom n'importe où Pascal de placer une
expression.
Affecter la valeur d'une fonction
Remarque : nous ne pouvons assigner une valeur à la valeur de la fonction
qu'à partir d'elle-même.
28

24. Bruno Delb http://www.brunodelb.com Date : 14/04/2001
Le langage Pascal
La définition n'intervenant qu'après appel
Dans des cas bien précis, il peut être utile de déclarer une fonction ou une
procédure après son appel dans le programme source. On utilise alors une
définition avec FORWARD.
Remarques
La programmation modulaire
Les procédures permettent de réaliser une chose très intéressante, à
savoir la conception d'un programme et la possibilité d'en faire ainsi un
module utilisable par d'autres programmes.
Un nom sera constitué selon la structure : <VERBE><NOM>.
Ces instructions permettent dès lors une programmation modulaire,
autrement dit, vous pourrez découper votre programme en plusieurs petits
blocs appelés procédures et fonctions. Si une procédure « fait » plus d'une
page affichable, essayez de la découper de façon logique.
Différencier variable globale et variable locale
Il pourra arriver qu'à la lecture d'une procédure ou d'une fonction, vous
oubliez si une variable particulière est globale ou locale. Pour une variable
locale NOM, nommer la variable correspondante globale GNOM.
Les paramètres d'entrée, de sortie, mixte
Un paramètre constitue l'interface entre la procédure et son
environnement. On définit les paramètres d'entrée comme étant les
données figurant dans la définition d'une procédure, et les paramètres de
sortie comme étant les données retournés par une procédure. On définit
également un paramètre mixte comme étant une donnée utilisée par une
procédure et modifiée après.
L’effet de bord
On observe ce qu'on appelle effet de bord lorsque le programme transmet
des résultats directement à une variable externe, dont sans utiliser un
paramètre VAR.
29

25. Bruno Delb http://www.brunodelb.com Date : 14/04/2001
Le langage Pascal
Les types de structures
Les constantes
Les constantes sont très similaires aux variables. Une constante peut être
assimilée à un emplacement de la mémoire de votre ordinateur où
l'information est stockée.
Modifier une constante [=]
Contrairement à une variable, vous ne pouvez pas modifier la valeur d'une
constante, exception faite pour les constantes modifiables par CONST nom :
type = valeur;
Déclarer une constante [Const]
La déclaration de constantes se fait comme suit :
CONST
nom = valeur;
Comme tout identificateur, nom doit suivre les règles de Pascal en ce qui
concerne les identificateurs.
Utiliser une expression dans la déclaration
Pascal ne permet pas l'tilisation d'expressions lors de la déclaration de
constantes, mais uniquement des valeurs directes.
Les types scalaires
Les types de données scalaires. Ces types de données permettent la
comparaison d'éléments à l'intérieur de ce type. Ainsi, chaque élément d'un
type de donnée scalaire doit soit plus grand, soit plus petit, ou égal à un
autre élément.
Déclarer un type scalaire
Vous spécifiez un nom identificateur, puis le =, et enfin les éléments du type
:
TYPE
nom = (nom1, nom2, nom3);
Le type ordinal
Les types ordinaux sont simplement une petute partue du groupe de types
scalaires, ce qui veut dire que tout élément d'un type ordinal ppeut être
trouvé dans un type scalaire. Toutefois, le type REAL est un type scalaire
mais par un type ordinal.
30

26. Bruno Delb http://www.brunodelb.com Date : 14/04/2001
Le langage Pascal
Les tableaux [Array]
En gros, un tableau est ene liste de valeurs accessibles chacunes par un
index (ou la position) dans le tableau.
La syntaxe est :
ARRAY [ limite inférieure..limite supérieure ]
OF type;
La portée des valeurs spécifiées entre les crochets doit être de type ordinal.
Les deux points (..) équivaut à « et toute valeur ordinale comprises entre ces
deux valeur ».
Accéder à un élément
Chaque emplacement est accessible par spécification de l'indice (ou numéro
de l'élément). Cela est fait par la simple adjonction du nom du tableau et de
l'indice entre crochets.
Utiliser des tableaux multidimensionel
Les tableaux multi-dimentionels sont ceux possédant plus d'une colonne.
Pour déclarer le tableau NOM à deux dimensions, vous devez écrire :
VAR
NOM: ARRAY [ 1..6, 1..2 ] OF STRING;
Le type déclarer dans un tableau peut être tout type déclaré.
Le type sous-porté
Un type « sous-porté » est un type dans lequel les éléments sont d'une
portée d'un autre standard ou d'un type défini par l'utilisateur. La syntaxe de
la déclaration d'un type sous-portée est :
TYPE
nomdutype = limite inférieure..limite supérieure;
Var
nom : type;
L’ensemble
Un jeu est un autre type structuré qui permet de faire quelque chose avec
tout élément de celui-ci en même temps.
La syntaxe de déclaration de jeux est :
TYPE
nomdejeu = SET OF typedebase;
où une fois encore nomdejeu doit suivre les règles imposées par Pascal sur
les noms. Typedebase est un type dont nous choisissons des éléments qui
doivent être stoqués dans le jeu.
31

27. Bruno Delb http://www.brunodelb.com Date : 14/04/2001
Le langage Pascal
Effectuer des opérations sur un ensemble
Voici ci-dessous une liste d'opérations que l'on peut opérer :
Opération Syntaxe
Réunion {ensemble1} + {ensemble2}
Ratrait {ensemble1} - {ensemble2}
Test inclus dans ? {élément} IN {ensemble}
Sous-ensemble TYPE sous_ensemble = debut..fin
ARRAY [sous_ensemble] OF TYPE
Délimiter des domaines de validité
Les constantes peuvent être utilisées en particulier pour fixer le domaine (de
validité, ...) d'un programme, ces limites n'étant évidement pas variables.
Utiliser les constantes pour le débogage
Une autre utilisation très pratique est celle faite pour trouver ce qui ne «
tourne pas rond » dans un programme :
CONST
TEST = TRUE;
puis
IF TEST THEN
BEGIN
WRITELN( 'ICI');
END;
Ainsi, suivant la valeur que vous assignerez à TEST, certaines instructions
seront exécutées ou non. Ceci est donc très pratique.
32