INTRODUCTION À LA PROGRAMMATION INF 1200

Transcription

INTRODUCTION À LA PROGRAMMATION
INF 1200
COMPLÉMENT D’INFORMATION
Dernière mise à jour : 12 décembre 2002
Le « Complément d’information » contient des informations supplémentaires sur le langage
de programmation PASCAL/DELPHI 3. Principalement, ces informations supplémentaires
portent sur les notions de base, sur les types de données, sur les opérateurs, sur les
instructions de lecture et d’écriture, sur les tableaux et les enregistrements, sur les structures
itératives, sur les procédures, sur les fonctions et sur les unités du langage PASCAL.
Télé-université
2000
TABLE DES MATIÈRES
1.
Structure d’un programme........................................................................................................1
1.1 PROGRAM.....................................................................................................................1
1.2 USES...............................................................................................................................1
1.3 LABEL............................................................................................................................2
1.4 CONST............................................................................................................................2
1.5 TYPE...............................................................................................................................2
1.6 VAR ................................................................................................................................3
1.7 Sous-programme .............................................................................................................3
1.8 BEGIN.............................................................................................................................3
1.9 Instructions du programme principal ..............................................................................4
1.10 END ................................................................................................................................4
1.11 Point-virgule....................................................................................................................4
1.12 Commentaires .................................................................................................................5
2.
TYPES DE DONNÉES DU LANGAGE PASCAL.................................................................6
2.1 Type Entier......................................................................................................................6
2.2 Type Réel ........................................................................................................................7
2.3 Type Caractère ................................................................................................................8
2.4 Type Booléen ..................................................................................................................9
2.5 Type Énuméré .................................................................................................................9
2.6 Type Intervalle ..............................................................................................................10
2.7 Type Ensemble..............................................................................................................11
2.8 Chaîne de caractères......................................................................................................12
2.9 Variables .......................................................................................................................13
2.10 Constantes .....................................................................................................................14
3.
OPÉRATEURS ......................................................................................................................16
3.1 Opérateurs arithmétiques ...............................................................................................16
3.2 Opérateurs relationnels ..................................................................................................17
3.3 Opérateurs booléens.......................................................................................................18
3.4 Opérateurs des ensembles..............................................................................................19
3.5 Expression .....................................................................................................................21
3.6 Instruction d’affectation.................................................................................................23
3.7 Manipulation des chaînes ..............................................................................................24
4.
LES INSTRUCTIONS DE LECTURE ET D’ÉCRITURE....................................................27
4.1 Lecture ...........................................................................................................................27
4.2 Remède pour les lectures impossibles ...........................................................................28
4.3 Écriture ..........................................................................................................................29
© Télé-université, 2003
Introduction à la programmation INF 1200
ii
5.
LES TABLEAUX ET LES ENREGISTREMENTS..............................................................36
5.1 Les tableaux ...................................................................................................................36
5.2 Les enregistrements .......................................................................................................38
5.3 Les pointeurs..................................................................................................................39
6.
LES STRUCTURES de contrôle............................................................................................40
6.1 Instruction IF. . THEN . . . ELSE..................................................................................40
6.2 Instruction CASE .. OF .................................................................................................43
6.3 Boucle WHILE .. DO....................................................................................................43
6.4 Instruction WHILE NOT EOF(fichier) DO ..................................................................47
6.5 Boucle REPEAT. . UNTIL ...........................................................................................48
6.6 Boucles FOR .................................................................................................................51
7.
LES PROCÉDURES ..............................................................................................................53
7.1 Variables globales .........................................................................................................54
7.2 Variables locales ...........................................................................................................54
7.3 Appel de procédure .......................................................................................................54
7.4 Transmission de paramètres..........................................................................................54
8.
LES FONCTIONS..................................................................................................................58
8.1 Variables globales .........................................................................................................59
8.2 Variables locales ...........................................................................................................59
8.3 Appel des fonctions.......................................................................................................59
9.
UNITÉS ..................................................................................................................................60
Bibliographie .................................................................................................................................63
1.
STRUCTURE D’UN PROGRAMME
Tout programme en PASCAL possède la structure suivante :
PROGRAM Nom_Programme;
USES
LABEL
CONST
TYPE
VAR
En-tête du programme
Liste_Unites;
Liste_Etiquettes;
Liste_Constantes;
Liste_Types;
Liste_Variables;
Partie de la
déclaration
du programme
Partie de déclarations des
SOUS-PROGRAMMES
(Procédures et fonctions)
BEGIN
Bloc principal
du programme
Instructions du
PROGRAMME PRINCIPAL
END.
1.1
PROGRAM
L’en-tête du programme comprend un mot réservé et le nom du programme. Voyons un
exemple : PROGRAM Nom_Programme;
PROGRAM :
Mot réservé du langage.
Nom_Programme :
Nom du programme
choisi par le programmeur.
Le programmeur pourrait choisir :
PROGRAM Structure_Programme;
1.2
USES
Cette instruction indique au compilateur quelles sont les bibliothèques de fonctions et de
procédures qui doivent être compilées dans le programme final; l’environnement
DELPHI 3 en inclut certaines automatiquement. Si vous écrivez votre propre programme,
vous devez inclure leur nom lorsque vous avez besoin des fonctions qu’elles contiennent.
USES Liste_Unites;
Exemple :
USES FORMS;
...
1.3
2
LABEL
LABEL est une suite de chiffres, dans l’intervalle 0 à 9999. Les zéros non significatifs
sont ignorés. Les labels sont utilisés avec l’instruction GOTO.
LABEL Liste_Etiquettes;
EXEMPLE 1.1
PROGRAM Exercice1;
USES FORMS;
{$R *.RES}
VAR Division : char;
LABEL
ICI;
BEGIN
ICI : WRITELN ('Bonjour');
WRITELN ('Voulez-vous exécuter une autre fois?');
READLN (Division);
IF (Division = 'o') THEN
GOTO ICI;
READLN
END.
Les instructions GOTO et LABEL ne sont pas obligatoires et sont très peu utilisées dans
un programme PASCAL.
1.4
CONST
Cette instruction permet de définir les constantes utilisées dans le programme.
CONST Liste_Constantes;
Exemple :
CONST Pi = 3.14159;
Cette instruction est optionnelle dans un programme PASCAL.
1.5
TYPE
Le mot clé sert à déclarer les nouveaux types inventés par le programmeur.
TYPE Liste_Types;
Exemple :
TYPE Inter = 1 . . 10;
Réponse = (Oui, Non);
1.6
3
VAR
Les variables sont des noms donnés à une adresse en mémoire, permettant ainsi de
consulter ou de modifier le contenu de cette dernière.
VAR Liste_Variables;
Exemple :
VAR Valeur : INTEGER;
Fin, Début : BOOLEAN;
1.7
Sous-programme
Cette partie se trouve entre la partie de déclaration et le bloc principal du programme.
Voyons un exemple de déclaration des SOUS-PROGRAMMES (Procédures, Fonctions)
d’un programme en PASCAL.
EXEMPLE 1.2
PROGRAM Exercice2;
USES FORMS;
{$R *.RES}
VAR Nom, Prenom : STRING[8];
NouveauNom : STRING[8];
Nouveauprenom : STRING[8];
Partie de la
déclaration
PROCEDURE ChangementPrenom;
BEGIN
Nom:='Rivard';
Prenom:='Joséphine-Baquère';
NouveauPrenom:='Angéline';
WRITELN('Le prénom est ', Prenom);
WRITELN('Le nom est ', Nom);
Prenom:=NouveauPrenom;
WRITELN('Le nouveau prénom est ', Prenom);
END;
BEGIN
ChangementPrenom;
READLN;
END.
1.8
BEGIN
Ce mot réservé est placé au début du programme principal et il est obligatoire dans un
programme PASCAL.
1.9
4
Instructions du programme principal
Cette partie contient toutes les instructions du programme.
EXEMPLE 1.3
PROGRAM Exercice3;
USES FORMS;
{$R *.RES}
VAR A : INTEGER;
BEGIN{Programme principal}
REPEAT
READLN(A);
IF A>0 THEN
WRITELN(A);
UNTIL A>=9;
END. {Fin du programme}
Cette partie est optionnelle dans un programme PASCAL.
1.10 END
Ce mot réservé, suivi d’un point (.), est obligatoire dans un programme PASCAL et il
indique la fin du programme.
1.11 Point-virgule
Le point-virgule (;) est obligatoirement utilisé pour séparer deux instructions. Voyons
l’exemple suivant.
X:=X + 1;
IF X>0 THEN
Y:=X;
...
Devant les mots « END » et « UNTIL », le point-virgule n’est pas obligatoire, il est
optionnel. Voyons l’exemple suivant.
IF Car = ' N ' THEN
BEGIN
REPEAT
READ(Nombre)
UNTIL Nombre< >A;
A:=0
END; {Fin du IF}
B:=A* 5;
...
5
Il ne faut jamais mettre de point-virgule devant le mot « ELSE ». Voyons l’exemple
suivant.
IF (N MOD 2) = 1 THEN
M := N DIV 10
ELSE
M := N;
...
1.12 Commentaires
On utilise des commentaires pour expliquer certaines parties d’un programme. Les blocs
ou lignes de commentaires doivent être encadrés par des parenthèses ( ) ou par des
accolades { }. Examinons l’exemple suivant.
...
VAR N : INTEGER;
...
(*Fonction qui calcule l’aire*)
...
FUNCTION Aire (R:REAL) : REAL;
BEGIN
(*Pi = 3.14.158*)
Aire := R*R3.14159;
END; {Fin d’Aire}
6
2.
TYPES DE DONNÉES DU LANGAGE PASCAL
2.1
Type Entier
Le type Entier est un type simple de l’information (type ordinal). Les valeurs de ce type
peuvent être représentées par deux notions différentes.
Décimale :
-566, 1234, +1
Hexadécimale :
10 $, +AC $, -D $
Il n’est pas nécessaire de placer le signe « + », qui représente un nombre positif, devant un
nombre entier (optionnel).
Dans la version PASCAL/DELPHI, il y a 7 sortes prédéfinies de type Entier.
Catégorie Type de données Description
Entier
SHORTINT
SMALLINT
LONGINT
2147483647.
INTEGER
BYTE
WORD
CARDINAL
Nombres entiers compris entre -128 et 127.
Nombres entiers compris entre -32768 et 32767.
Nombres entiers compris entre -2147483647 et
Varient en fonction de l’implémentation.
Nombres entiers compris entre 0 et 255.
Nombres entiers compris entre 0 et 65535.
Varient en fonction de l’implémentation. Dans
cette version de PASCAL, CARDINAL est
semblable à INTEGER, mais n’autorise que les
valeurs positives.
EXEMPLE 2.1
PROGRAM Exercice1;
(* Ce programme imprime un nombre entier. *)
USES
FORMS;
{$R *.RES}
VAR
Nombre : INTEGER;
BEGIN
Nombre:=266;
WRITELN('C''est bien un nombre entier : ', nombre);
READLN;
END.
2.2
7
Type Réel
Le type Réel est un type simple de l’information (type ordinal). Les valeurs de ce type
peuvent être représentées par deux notions différentes.
Avec un point décimal :
5.0, 134.78, +9163.2322
Avec un exposant :
1.4E-12, -16E2, +9163.6322
Note.– L’exposant « E » signifie « multiplié par 10 à la puissance ».
Exemple : -16E2 = -16 x 10e2
En PASCAL, il y a cinq sortes prédéfinies de type Réel.
Catégorie Type de données
Réel
Description
SINGLE
Nombre dont la partie fractionnaire peut contenir
7 ou 8 chiffres significatifs.
DOUBLE
EXTENDED
CURRENCY
Nombre réel à forte précision, stocké au format
entier, autorise quatre places décimales.
REAL
11 ou 12 chiffres significatifs. Utilisez ce type
seulement pour la compatibilité avec les versions
précédentes de Borland PASCAL. Les types Double
et Extended sont recommandés dans tous les autres cas.
EXEMPLE 2.2
PROGRAM Exercice1;
(* Ce programme imprime un nombre réel. *)
USES FORMS;
{$R *.RES}
VAR
NombreR : REAL;
BEGIN
NombreR:=266.99;
WRITELN('C''est bien un nombre réel : ', NombreR:5:2);
READLN;
END.
2.3
8
Type Caractère
Le type Caractère est un type simple de l’information (type ordinal). Il y a 256 caractères
en PASCAL et les valeurs de ce type sont encadrées par deux apostrophes.
Exemple : ' a ', ' * ',
' | '
Note.– Un espace (blanc) est marqué par deux apostrophes « ' ' »;
l’apostrophe dans un mot d’un texte est marqué par deux apostrophes
successifs « '' ».
On compte dans la version PASCAL/DELPHI trois sortes de type Caractère.
Description
Caractère ANSICHAR
WIDECHAR
CHAR
Un caractère ANSI.
Un caractère UNICODE.
Varie en fonction de l’implémentation. Dans
cette version du PASCAL, CHAR est semblable
à ANSICHAR.
Un autre moyen de représenter un caractère avec PASCAL est de spécifier sa valeur
d’ordre ASCII (American Standard Code for Information Interchange) en la faisant
précéder du symbole « # ». Voici la table du jeu de caractère ASCII.
Notes.–
Le caractère NUL (#0) est un caractère nul.
Le caractère CR (#13) est la touche Enter (ou Return).
Le caractère BEL (#7) est un signal sonore (cloche).
Le caractère ' ' (#32) est un espace (un blanc).
Voyons quelques exemples.
Le caractère « F » est équivalent à #70 (en décimale) ou #46 (en hexadécimale).
Le caractère « è » est équivalent à #138 (en décimale) ou #$8A (en hexadécimale).
Il existe deux fonctions, déjà implantées en PASCAL, pour manipuler les caractères :
ORD : Retourner l’ordre d’un caractère.
CHR : Retourner un caractère.
ORD ( ' 1 ' ) = 49
ORD ( ' ] ' ) = 91
CHR (49) = ' 1 '
CHR (206) = ' + '
9
EXEMPLE 2.3
PROGRAM Caractere1;
(* Ce programme imprime un espace blanc. *)
USES
FORMS;
{$R *.RES}
VAR
Espace : CHAR;
BEGIN
Espace:=#32;
WRITELN(' Le chiffre #32 est bien un espace blanc : >’, Espace, ‘<’);
READLN;
END.
2.4
Type Booléen
Le type Booléen ou (Boolean) est un type simple de l’information (type ordinal). Les deux
valeurs possibles sont TRUE (vrai) et FALSE (Faux). Ce type est aussi qualifié de
logique. Il existe trois fonctions, déjà implantées en PASCAL, pour manipuler les valeurs
du type booléen.
ORD :
Retourner l’ordre d’une valeur
ORD(FALSE)
=0
ORD(TRUE)
=1
SUCC :
Retourner le successeur d’une valeur
SUCC(FALSE)
= TRUE
SUCC(TRUE)
= TRUE
PRED :
Retourner le prédécesseur d’une valeur
PRED(TRUE)
= FALSE
2.5
Type Énuméré
Le type Énuméré est un type simple de l’information (type ordinal). Le type Énuméré
consiste en une séquence ordonnée d’identificateurs, où chaque identificateur s’interprète
comme une donnée individuelle dont le diagramme syntaxique de la déclaration est
présenté comme suit :
Type Identificateur = (Identificateur1, Identificateur2, . . . . . . . ,
IdentificateurN);
où Identificateur1 < Identificateur2 < . . . . . . . . . . . < IdentificateurN.
Note.– Les identificateurs sont encadrés par des parenthèses et séparés par des
virgules.
TYPE Resultat = (Succes, Echec);
TYPE Sexe
= (Masculin, Feminin);
TYPE Semaine=
(Lundi, Mardi, Mercredi, Jeudi, Vendredi,
Samedi, Dimanche);
10
Notez que les identificateurs ne peuvent être un mot réservé. Par exemple, la déclaration
suivante est invalide :
TYPE Note = (Do, Re, Mi, Fa, Sol, La, Si) ;
« Do » est un mot réservé (boucle FOR . . TO . . DO)
Il existe 3 fonctions, déjà implantées en PASCAL/DELPHI, pour manipuler ces
identificateurs.
ORD : Retourner l’ordre d’un identificateur.
SUCC : Retourner le successeur d’un identificateur.
PRED : Retourner le prédécesseur d’un identificateur.
Note.– L’ordre du premier identificateur est égal à zéro. L’ordre du dernier
identificateur est égal à (N - 1), où N est le nombre d’identificateurs déclarés.
Voyons un exemple.
TYPE Taille
=
ORD(Petite)
=
ORD(Moyenne) =
ORD(Grande) =
SUCC(Petite)
=
SUCC(Moyenne) =
PRED(Grande)
PRED(Moyenne) =
(Petite, Moyenne, Grande);
0
1
2
Moyenne
Grande
= Moyenne
Petite
Note.– PRED(Petite) et SUCC(Grande) sont invalides.
2.6
Type Intervalle
Le type Intervalle est un type simple de l’information (type ordinal). Si certaines données
de type ordinal (Entier, Booléen, Caractère) ne prennent qu’un certain nombre de valeurs
comprises dans un intervalle, on pourra définir un nouveau type leur correspondant, dont
le diagramme syntaxique de la déclaration se présente comme suit :
TYPE Identificateur = Constante1 . . Constante2;
Notez que Constante1 doit être inférieure ou égale à Constante2
(Constante1 <= Constante2) et que les constantes peuvent être de type Entier, Caractère
ou Booléen, mais pas Réel.
Voyons des exemples.
TYPE Age = 1 .. 100;
TYPE Chiffre = '0' .. '9';
TYPE Mois = 1 .. 12;
La déclaration suivante est invalide :
TYPE Prix = 0 .. 999.9;
11
EXEMPLE 2.4
PROGRAM Project1;
(* Ce programme utilise le type Intervalle *)
USES
FORMS;
{$R *.RES}
TYPE Numero = '0' .. '9';
VAR BonNumero : Numero;
BEGIN
BonNumero :='4';
WRITELN(BonNumero);
READLN;
END.
2.7
Type Ensemble
Le type Ensemble est un type structuré de l’information. Le type Ensemble est une
collection de données simples et ordonnées qui sont toutes de même type, dont le
diagramme syntaxique de la déclaration se présente comme suit.
TYPE Identificateur = SET OF Type_de_Base;
Type_de_Base doit être un type ordinal (Entier, Booléen, Caractère, sauf Réel) ou un type
Intervalle de type ordinal et ne peut contenir plus de 256 éléments.
TYPE Majuscule = SET OF 'A' .. 'Z';
TYPE Chiffre = SET OF 0 .. 9;
TYPE Jour = (Lu, Ma, Me, Je, Ve, Sa, Di);
Journee = SET OF Jour;
La déclaration suivante est invalide car Type_de_Base comporte trop d’éléments.
TYPE Nombre = SET OF 1 ..350;
TYPE Valeur = SET OF INTEGER;
Traitons maintenant de la construction d’un ensemble. La paire de crochets [ ] sert à créer
une valeur de type Ensemble. Notez que [ ] est un ensemble vide.
['e', 'h', 'p'] est un ensemble constitué de 3 caractères.
[2, 4, 6, 8, 10] est un ensemble constitué de 5 entiers.
[2, 3, 7, 9 .. 16] est un ensemble constitué de 11 entiers.
La construction suivante est invalide, car les éléments de l’ensemble ne sont pas de même
type.
[43, 'd', 108]
12
EXEMPLE 2.5
PROGRAM Project1;
(* Ce programme utilise le type Ensemble. *)
USES
FORMS;
{$R *.RES}
TYPE Touche = SET OF CHAR;
VAR
EntreTouche : Touche;
EntreeUtilisateur : CHAR;
BEGIN
EntreTouche := ['0' .. '9'];
READ(EntreeUtilisateur);
IF EntreeUtilisateur IN EntreTouche THEN
WRITELN('C''est bien une touche numérique.');
READLN;
END.
2.8
Chaîne de caractères
Une chaîne de caractères est une suite de caractères d’une longueur maximale spécifique
et dont le diagramme syntaxique de la déclaration se présente comme suit.
TYPE Type_Chaine = STRING[Longueur];
En PASCAL, il y a trois sortes prédéfinies de type Chaine.
Chaîne
Description
SHORTSTRING
ANSISTRING
Séquence pouvant comporter jusqu’à 255 caractères.
Chaîne de taille dynamique de longueur
théoriquement illimitée.
STRING
Varie en fonction de la directive de compilation $H.
Par défaut, STRING est semblable à ANSISTRING.
Une chaîne de caractères doit être encadrée par deux apostrophes. Voyons des exemples.
'apprentissage en DELPHI'
'123 789'
' ' (Chaîne vide)
Note.– S’il existe des apostrophes dans une chaîne de caractères, il faut mettre
l’apostrophe en double. Par exemple, 'Aujourd''hui, c''est lundi'.
2.9
13
Variables
Les variables sont des informations dont la valeur peut changer au cours de l’exécution du
programme. Chaque variable doit être déclarée en spécifiant le type avant d’apparaître
dans un programme. Le diagramme syntaxique de la déclaration se présente comme suit.
VAR Liste_Identificateurs : Descrip_Type:
Note.– Liste_Identificateurs comprend un ou plusieurs identificateurs séparés par
des virgules. Descrip_Type est la description du type (type simple ou structuré).
Voyons des exemples de variables.
VAR Nombre1, Nombre2, Nombre3 : SINGLE;
VAR Nombre_Etudiant : WORD;
VAR Débordement : BOOLEAN;
TYPE
VAR
Distance = 1 .. 240;
X, Y : CHAR;
D : Distance;
TYPE
VAR
TYPE
Phrase = STRING[79];
P1, P2 : Phrase;
Jour = (Lu, Ma, Me, Je, Ve, Sa, Di);
Chiffre = SET OF '0' .. '9';
Jr : Jour;
C1, C2 : Chiffre;
VAR
On peut déclarer directement une variable que l’on associe à un type. Par exemple :
Au lieu de : TYPE Phrase = STRING[79];
VAR P1, P2 : Phrase;
On écrit :
VAR P1, P2 : STRING[79];
Au lieu de :
On écrit :
TYPE Distance = 1 .. 240;
VAR X, Y : CHAR;
D : Distance ;
VAR X, Y : CHAR;
D : 1 .. 240;
Quand on déclare une variable, la mémoire réserve une place pour stocker sa valeur. Par
exemple :
Rayon
VAR Rayon : REAL;
A
B
VAR A, B : INTEGER;
S
VAR S : STRING[50];
14
2.10 Constantes
Les constantes sont des informations dont la valeur demeure inchangée tout au long du
programme. Une constante doit toujours être définie avant d’apparaître dans une
instruction. Le diagramme syntaxique de la déclaration se présente comme suit.
CONST Identificateur = Constante;
Une constante doit être de type simple. Voyons quelques exemples.
CONST
PI
= 3.14159
CONST
Capacite
Succes
= 1320;
= TRUE;
CONST
Message
Moins_Un
Tauxtaxe
Continue
= 'Delphi';
= -1;
= 0.13;
= '0';
Quand on déclare une constante, la mémoire réserve une place pour stocker sa valeur.
CONST Seuil = 0.5;
...
CONST X = -9;
Y = 'n';
...
CONST S = 'Hello';
0.5
-9
'n'
'Hello'
EXEMPLE 2.6
PROGRAM Salaire;
(*Ce programme calcule le salaire net d’une personne.*)
USES
FORMS;
{$R *.RES}
CONST
Impot = 0.20;
Heure = 20.00;
Coutsuppl = 30.00;
TotalNormal35 = 35;
VAR
Nom : STRING[15];
Prenom : STRING[15];
Annee : INTEGER;
SalaireBrut : CURRENCY;
15
Salaire35 : CURRENCY;
SalaireNet : CURRENCY;
HeureSuppl : CURRENCY;
TotalHeure : CURRENCY;
SalaireSupp : CURRENCY;
TotalImpot : CURRENCY;
BEGIN
WRITE('Entrez votre prénom : ');
READLN(Prenom);
WRITE('Entrez votre nom : ');
READLN(Nom);
WRITE('Entrez le nombre d''heures : ');
READLN(TotalHeure);
IF TotalHeure > TotalNormal35 THEN
(*Calcule le salaire si la personne a fait des heures supplémentaires*)
HeureSuppl := TotalHeure - TotalNormal35;
SalaireSupp := HeureSuppl * Coutsuppl;
Salaire35 := TotalNormal35 * Heure;
SalaireBrut := Salaire35 + Salairesupp;
TotalImpot := SalaireBrut * Impot;
SalaireNet := SalaireBrut - TotalImpot;
(*Calcule le salaire si la personne n’a pas fait d’heures supplémentaires*)
IF TotalHeure <= TotalNormal35 THEN
SalaireBrut := Heure * TotalHeure;
TotalImpot := SalaireBrut * Impot;
SalaireNet := SalaireBrut - TotalImpot;
WRITELN; WRITELN; WRITELN;
WRITELN ('Prénom : ', Prenom,' Nom : ' , Nom);
WRITELN;
WRITELN('Total salaire brut : ', SalaireBrut:8:2 );
WRITELN('Total à payer en impôt : ', TotalImpot:8:2 );
WRITELN('Total salaire net : ', SalaireNet:8:2 );
READLN;
END.
16
3.
OPÉRATEURS
3.1
Opérateurs arithmétiques
Les opérateurs arithmétiques sont utilisés pour effectuer des opérations de type numérique
(Réel, Entier).
3.1.1 Opérateurs pour le type Entier
Opérateur
Signification
Type de résultante
+
Addition
Entier
-
Soustraction
Entier
-
Opposé
Entier
*
Multiplication
Entier
/
Division
Réel
DIV
Division tronquée
Entier
MOD
Reste de la division
Entier
Addition
10 + 2 vaut 12
Soustraction
6 - 60 vaut -54
Opposé
Si X vaut -8 alors
-X vaudra 8
Multiplication
4 * 7 vaut 28
Division
18 / 6 vaut 3.0
Division tronquée
4 DIV 3 vaut 1
Reste de la division 10 MOD 6 vaut 4
3.1.2 Opérateurs pour le type Réel
Opérateur
Signification
Type de résultante
+
Addition
Réel
-
Soustraction
Réel
-
Opposé
Réel
*
Multiplication
Réel
/
Division
Réel
17
3.2
Addition
Soustraction
10.1 + 2.6 Vaut 12.7
6.7 - 60.8 vaut -54.1
Opposé
Si X vaut 39.23 alors
-X vaudra -39.23
Multiplication
4.22 * 7 vaut 29.54
Division
18.6/ 3.0 vaut 3.2
Opérateurs relationnels
Opérateur
Signification
Type de résultante
=
égal
Booléen
<>
différent
Booléen
<
inférieur
Booléen
>
supérieur
Booléen
<=
inférieur ou égal
Booléen
>=
supérieur ou égal
Booléen
<=
sous-ensemble de
Booléen
>=
sur ensemble de
Booléen
IN
membre de
Booléen
Égal à
8 = 8 vaut TRUE
Différent de
17.3 <> 2.9
vaut TRUE
Inférieur à
19 < 178
vaut TRUE
Supérieur à
2484 > 3893 vaut FALSE
12.5 > 0.3
vaut TRUE
Inférieur ou égal à
26 <= 26
99 <= 14
10 <= 19
Supérieur ou égal à
12.48 >= 972.1 vaut FALSE
12362 >= 11232 vaut TRUE
99999 >= 99999 vaut TRUE
vaut TRUE
vaut FALSE
vaut TRUE
18
Test d’appartenance :
12 IN [0 .. 200]
2 IN [3 .. 128]
vaut TRUE
vaut FALSE
'k' IN ['a' .. 'z']
vaut TRUE
ORD ('S') IN [1 .. 92 ] vaut FALSE
CHR(48) IN ['!' .. '*']
vaut FALSE
'O' IN ['O', 'N']
vaut TRUE
Notez que la valeur à tester ne peut être un nombre réel ou une chaîne de
caractères. Par exemple, les opérateurs suivants sont invalides.
2.19 IN [0 .. 3]
'Oui' IN ['O', 'N']
3.3
Opérateurs booléens
Les opérateurs booléens (opérateurs logiques) permettent la combinaison d’opérandes de
type Booléen pour former des expressions de type Booléen (OR, AND) et pour inverser la
valeur d’un opérande.
Opérateur
AND
X
TRUE
TRUE
FALSE
FALSE
Y
TRUE
FALSE
TRUE
FALSE
Opérateur
OR
X
TRUE
TRUE
FALSE
FALSE
Y
TRUE
FALSE
TRUE
FALSE
Opérateur
NOT
X
TRUE
FALSE
Y
FALSE
TRUE
X AND Y
TRUE
FALSE
FALSE
FALSE
X AND Y
TRUE
TRUE
TRUE
FALSE
Notez que ces opérateurs peuvent également porter sur des entiers. (Voir la section 3.5 :
Expression).
3.4
19
Opérateurs des ensembles
3.4.1 Opérateur de réunion
La réunion de deux ensembles est l’ensemble formé des éléments appartenant au moins à
l’un des deux ensembles. En PASCAL, la réunion de deux ensembles est représentée par
l’opérateur « + ». Voyons quelques exemples.
TYPE Lettre = SET OF 'A' .. 'Z';
VAR E1, E2, E : Lettre;
...
E1 := ['G'] ;
E2 := ['D'] ;
E
:= E1 + E2;
L’ensemble E vaudra ['G', 'D'].
...
E1 := ['T'];
E := E1 + [ ];
L’ensemble E vaudra ['T'].
Ensemble vide
3.4.2 Opérateur d’insertion
L’insertion de deux ensembles est l’ensemble formé des éléments appartenant
simultanément aux deux ensembles. En PASCAL, l’insertion de deux ensembles est
représentée par l’opérateur « * ». Voyons quelques exemples.
TYPE Lettre = SET OF 0 .. 9;
VAR E1, E2, E : Numero;
...
E1 := [0, 1, 2, 3'] ;
E2 := [0, 3, 8] ;
E
:= E1 * E2;
L’ensemble E vaudra [0, 3'].
...
E1 := [2, 4, 6];
E := E1 * [ ];
L’ensemble E vaudra [ ].
Ensemble vide
3.4.3 Opérateur de différence (complémentaire relatif)
Si E1 et E2 sont deux ensembles, la différence entre eux (E1 - E2) est l’ensemble formé
des éléments appartenant à E1 et n’appartenant pas à E2. En PASCAL, la différence de
deux ensembles est représentée par l’opérateur « - ».
20
Voyons un exemple.
TYPE Couleur = SET OF (Blanc, Rouge, Bleu, Jaune);
VAR E1, E2, E : Couleur;
...
E1 := [Blanc, Bleu, rouge];
E2 := [Bleu];
E := E1 - E2;
L’ensemble E vaudra [Blanc, Rouge].
...
E1 := [Jaune];
E := E1 - [ ];
Ensemble vide
L’ensemble E vaudra [Jaune].
3.4.4 Opérateurs de commande
Il y a deux opérateurs de commande : égalité (:=) et inclusion (<=).
Il y a égalité de deux ensembles (E1 = E2), si E1 et E2 sont formés des mêmes éléments.
Voyons un exemple.
TYPE Lettre = SET OF 'a' .. 'n'];
Var E1, E2 : Lettre;
...
E1 := ['f', 'i', 'm'];
E2 := ['m', 'f', 'i'];
Donc E1 = E2.
Il y a inclusion de deux ensembles (E1 <= E2), si E1 est inclus dans E2, c’est-à-dire si
tous les éléments de E1 appartiennent à E2. Voyons un exemple.
TYPE Chiffre = SET OF '0' .. '9';
Var E1, E2 : Chiffre;
...
E1 := ['3', '7'];
E2 := ['3', '5', '7', '9'];
Donc E1 <= E2.
...
E1 := ['2', '4', '6', '8'];
E2 := ['4', '2', '8', '6'];
Donc E1 <= E2 (ou E2 <= E1).
3.5
21
Expression
L’expression est un groupe d’opérandes (une succession de calculs) liées par certains
opérateurs pour former un terme algébrique qui représente une valeur, c’est-à-dire un
élément de donnée simple. Voyons des exemples.
X+Y+Z
(B * B - 4 * A * C) / (2 * A)
(P AND Q) OR (NOT P OR R)
En PASCAL, il y a deux sortes d’expression :
– l’expression numérique qui représente une valeur numérique
Exemple : (B * B - 4 * A * C) / (2 * A)
– l’expression booléenne qui représente une condition logique (TRUE ou FALSE)
Exemple : (P AND Q) OR (NOT P OR R)
Considérons l’expression suivante :
12 + 5 * 2 DIV 4 - 10
Notez qu’il est impossible de prévoir le résultat sans connaître l’ordre dans lequel vont
s’effectuer les opérations ou la priorité des opérations.
3.5.1 Liste des propriétés des opérateurs
Opérateur
Priorité
Catégorie
(. . .)
1
Expression entre parenthèses
NOT ou -
2
Unaires
*, /, DIV, MOD, AND
3
Multiplicatifs
+, _, OR
4
Additifs
+, <>, <, >, <=, >=, IN
5
Relationnels
3.5.2 Règles d’évaluation
Voyons les règles d’évaluation et effectuons quelques exercices.
– Une opérande entre deux opérateurs sera associée à celui qui possède la priorité la plus
élevée.
– Une opérande entre deux opérateurs de même priorité sera associée à celui qui se
retrouve à gauche
22
EXERCICE 1
Si les entiers A, B, C, D valent respectivement 21, 4, 4, 3, évaluez les expressions
suivantes.
1. A MOD B + A DIV B * B
2. A + B / C * D
3. (A * D - D * (10 + D)) DIV 4
4. (A > 2 AND ) AND (A >= 100)
5. -C + B - A DIV D
Solutions
1. A MOD B + A DIV B * B
21 MOD 4 + 21 DIV 4 * 4
1+5*4
1 + 20
21
Donc A MOD B + A DIV B * B vaut 21.
2.
A+B/C*D
21 + 4 / 4 * 3
21 + 1 * 3
21 +3
24
Donc A + B / C * D vaut 24.
3.
(A * D - D * (10 + D)) DIV 4
(21 * 3 - 3 * (10 + 3)) DIV 4
(21 * 3 - 3 * 13) DIV 4
(63 - 39) DIV 4
24 DIV 4
6
Donc (A * D - D * (10 + D) DIV 4 vaut 6.
4.
(A > 2) AND (A >= 100)
(21 > 2) AND (21 >= 100)
TRUE AND FALSE
FALSE
Donc (A > 2) AND (A >= 100) vaut FALSE.
5.
-C + B - A DIV D
- 4 + 4 - 21 DIV 3
(Unaire)
-4 + 4 - 21 DIV 3
-4 + 4 - 7
0-7
-7
Donc -C + B - A DIV D vaut -7.
23
EXERCICE 2
Soit X un entier, Y et Z deux booléens, qui valent respectivement 18, FALSE et TRUE.
Évaluez les expressions suivantes.
1.
(X In [1 .. 7]) AND Y
2.
Not Y or (Y AND Z)
Solutions
1.
(X IN [1 .. 7]) AND Y
(18 IN [1 .. 7]) AND FALSE
FALSE AND FALSE
FALSE
Donc (X IN [1 .. 7]) AND FALSE vaut FALSE.
2.
NOT Y OR (Y AND Z)
NOT FALSE OR (FALSE AND TRUE)
NOT FALSE OR FALSE
TRUE OR FALSE
TRUE
Donc NOT Y OR (Y AND Z) vaut TRUE.
3.6
Instruction d’affectation
L’instruction d’affectation est un type d’instruction simple servant à assigner un élément
de donnée à une variable dont le diagramme syntaxique se présente comme suit :
Variable := Element_De_Donnee;
Element_De_Donnee peut être une constante, une autre variable, une expression ou une
référence fonction (qu’on verra plus loin). Le point-virgule (;) agit comme séparateur pour
distinguer la fin de l’instruction en cours du commencement de la prochaine instruction.
deux exemples.
CONST C = 50.0;
VAR X, Y : REAL;
Affectation à
...
↓
X := 78.5;
X une constante
X := C;
X une constante
Y := X - C;
Y une expression
L’exemple ci-dessus contient trois instructions.
VAR I, J : INTEGER;
...
J := I DIV 10;
I := J * 5;
Affectation à
↓
J une expression
I une expression
I := SQR (J);
J := I;
24
I une fonction
J une autre variable
Note.– SQR est une fonction prédéfinie.
L’exemple ci-dessus contient quatre instructions.
Si Element_De_Donnee (partie à droite) est une expression ou une référence fonction,
alors cette partie sera évaluée avant l’affectation.
Si on affecte une nouvelle valeur à une variable, alors son contenu (sa valeur) sera changé
par cette nouvelle valeur. Voyons l’exemple qui suit.
VAR A, B, C : BOOLEAN;
...
A := TRUE;
B := TRUE;
C := NOT B;
A := (NOT B) OR C;
A
TRUE
A
FALSE
Donc, A vaut présentement FALSE.
3.7
Manipulation des chaînes
3.7.1 Affectation
On peut affecter les chaînes de caractères même lorsque les chaînes qu’on affecte ne sont
pas déclarées de même longueur que la variable réceptrice. Par exemple :
VAR Chaine1 : STRING[5];
Chaine2 : STRING[14];
Voici des affectations qui sont bonnes :
Chaine1 := 'Hello';
Chaine1 := 'Moi';
Chaine2 := Chaine1;
Chaine2 := 'Tout le monde';
Lorsque la variable réceptrice a une longueur maximum inférieure à la longueur de la
chaîne qu’on cherche à lui affecter, celle-ci est simplement tronquée (coupée) par la
droite. Par exemple :
VAR Chaine1 : STRING[5];
Chaine2 : STRING[10];
...
Chaine2 := 'Comment ca va';
Chaine1 := Chaine2;
On obtiendra simplement dans Chaine2, la chaîne 'Comment ca', et dans Chaine1 la
Chaîne 'Comme'.
25
3.7.2 Comparaison
On peut comparer les chaînes de caractères grâce à l’ordre des codes ASCII de chacun des
caractères qui les constituent ou leur longueur. Voyons des exemples, soit les 5 chaînes de
caractères suivantes :
Chaine1 : BONJOUR'
Chaine2 : 'PASCAL'
Chaine3 : 'BONJOUR'
Chaine4 : 'Passe'
Chaine5 : 'BONJO'
1.
Chaine1 et Chaine3 sont égales.
2.
Chaine1 est plus petite que Chaine2, car l’ordre du premier caractère de
Chaine1 est plus petit que l’ordre du premier caractère de Chaine2.
3.
Chaine2 est plus petite que Chaine4, car l’ordre du quatrième caractère de
Chaine2 est plus petit que l’ordre du quatrième caractère de Chaine4.
4.
Chaine5 est plus petite que chaine1, car la longueur de Chaine5 est inférieure
à la longueur de Chaine1.
Notez qu’il existe une fonction, déjà implantée dans PASCAL, pour calculer la longueur
des chaînes de caractères; elle s’appelle « Length ».
Exemple :
Length ('CE JOUR') vaut 7.
3.7.3 Addition (concaténation)
Cette opération permet d’unir deux ou plusieurs chaînes pour n’en former qu’une seule.
Voyons des exemples, soit les chaînes de caractères suivantes :
C1 : 'Comment '
C2 : 'ca'
C3 : 'va'
C1 + C2 vaut : 'Comment ca'
C1 + C2 + C3 vaut : 'Comment ca va'
Notez qu’il existe une fonction, déjà implantée en PASCAL, pour additionner les chaînes
de caractères; elle s’appelle « Concat ». Par exemple :
VAR C1 : STRING[8];
C2 : STRING[14];
...
C1 := 'Comment';
C2 := Concat (C1, ' ca va ');
On obtiendra dans C2 la chaîne 'Comment ca va'.
26
3.7.4 Extraction de sous-chaînes
Il existe une fonction, déjà implantée en PASCAL, pour extraire les chaînes de caractères;
elle s’appelle « Copy ». Cette fonction permet d’extraire une partie (sous-chaîne) d’une
chaîne, d’une longueur donnée à partir d’une position donnée.
Voyons l’exemple qui suit.
Var C1 : STRING[8];
C2 : STRING[14];
...
C1 := 'PASCAL';
C2 := COPY (C1, 2,3);
On obtiendra dans C2 la chaîne 'asc'.
C1 := COPY('Version', 1,3);
On obtiendra dans C1 la chaîne 'Ver'.
27
4.
LES INSTRUCTIONS DE LECTURE ET D’ÉCRITURE
4.1
Lecture
La lecture sert à recopier tous les caractères frappés au clavier et à affecter ces valeurs aux
variables concernées. La lecture est utilisée seulement pour les variables. Il est interdit de
lire une constante.
En PASCAL, la lecture est représentée par l’une des deux instructions suivantes :
READ(C1 [,C2, C3, …, Cn]);
READLN(C1 [,C2, C3, …., Cn]);
Note.– Une ou plusieurs valeurs (ou variables).
On peut lire une ou plusieurs variables. Lorsqu’on lit plusieurs variables, il faut les séparer
par un ou plusieurs espaces entre deux variables lues. La fin d’une lecture est validée par
la touche Return (Enter ↵).
La différence entre l’instruction READ et l’instruction READLN est la suivante :
– Avec l’instruction READ, le curseur de l’écran reste en place après avoir terminé la
lecture.
– Avec l’instruction READLN, le curseur de l’écran passe au début de la ligne suivante
après avoir terminé la lecture.
Voyons un exemple.
VAR X, Y : REAL;
N : INTEGER;
...
READLN(N);
READ(X, Y);
Le curseur de l’écran attend une valeur entière frappée au clavier.
Supposons qu’on frappe la valeur 18 sur le clavier, cette valeur sera affectée à la variable
N concernée.
18
↓
Valeur frappée
↵
N
↓
Touche Return
↓
18
↓
Affectation à la variable concernée
Le curseur de l’écran passe au début de la ligne suivante après avoir terminé la
lecture de la première ligne.
28
Supposons qu’on frappe sur le clavier deux valeurs, soit 2.5 et 0.3; ces valeurs seront
affectées aux variables X et Y concernées.
2.5
0.3
↵
↓ ↓
↓
↓ Espace frappée
Touche Return
↓ par l’usager
↓
Valeurs frappées
Affectation aux variables concernées :
2.5 → X
0.3 → Y
Notez...
– qu’on ne peut que lire les variables des types suivants :
Entier
Réel
Caractère
Intervalle
– qu’il est interdit de lire les variables des types suivants :
Booléen
Énuméré
Ensemble
Tableau
Enregistrement
Fichier
(On verra ces trois derniers types plus loin.)
Sachez, par ailleurs, qu’il existe des remèdes pour la lecture des variables des types
Booléen et Énuméré.
4.2
Remède pour les lectures impossibles
Il s’agit de lire une autre variable (du type qui permet la lecture), puis d’affecter la valeur
lue à la variable qu’on veut lire.
4.2.1 Type Booléen
Voyons un exemple.
VAR Faim : Boolean;
Car : CHAR;
...
WRITE ('As-tu faim (O/N) ?');
READLN(Car);
IF Car IN ['o', 'O'] THEN
Faim := TRUE
29
ELSE
Faim := FALSE;
...
IF Faim THEN
...
4.2.2 Type Énuméré
Voyons un exemple :
TYPE Reponse = (OUI, Non);
VAR Faim : Reponse;
Car : CHAR;
...
WRITE ('As-tu faim (O/N) ?');
READLN(Car);
IF Car IN ['o', 'O'] THEN
Faim := OUI
ELSE
Faim := Non;
...
IF Faim = Oui THEN
4.3
Écriture
L’écriture permet d’afficher le contenu d’une variable ou d’une constante. En PASCAL,
l’écriture est représentée par l’une des deux instructions suivantes :
WRITE(C1 [,C2, C3, …, Cn]);
WRITELN(C1 [,c2, C3, …., Cn]);
Note.– Une ou plusieurs valeurs (ou variables).
La différence entre l’instruction WRITE et l’instruction WRITELN est la suivante :
– Avec l’instruction WRITE, le curseur de l’écran reste en place après avoir terminé
l’écriture.
– Avec l’instruction WRITELN, le curseur de l’écran passe au début de la ligne suivante
après avoir terminé l’écriture.
On peut écrire seulement les variables des types suivants :
Entier
Réel
Caractère
Intervalle
Booléen
30
Par ailleurs, il est interdit d’écrire les variables des types suivants :
Énuméré
Ensemble
Tableau
Enregistrement
Fichier
4.3.1 Écriture des entiers
Sans format
L’écriture est effectuée de gauche à droite.
WRITE(Un_Entier[,…]);
WRITELN(Un_Entier[,…]);
Voyons un exemple.
VAR N, M : INTEGER;
...
N := 145;
M := N + 1;
WRITELN (N);
WRITE(N, M);
Apparaîtra à l’écran :
145
145146
Explication
– Avec « WRITELN(N); », la valeur de N est écrite à partir de la première colonne. Le
curseur passe ensuite au début de la ligne suivante.
– Avec « WRITE(N, M); », la valeur de N sera écrite à partir de la première colonne,
puis la valeur de M sera écrite à partir de la quatrième colonne.
Avec format
WRITE(Un_Entier: E[,…]);
WRITELN(Un_Entier:E[,…]);
↓
Espaces à réserver
Voyons un exemple.
VAR N, M : INTEGER;
...
N := 145;
M := N + 1;
WRITELN (N:4);
WRITE(N, M:6);
31
145
145
146
Explication
– Avec « WRITELN(N:4); », quatre espaces seront réservées pour l’écriture de la valeur
de N. Le curseur passe ensuite au début de la ligne suivante.
– Avec « WRITE(N, M:6); », la valeur de N sera écrite à partir de la première colonne,
ensuite six espaces seront réservées pour l’écriture de la valeur de M.
4.3.2 Écriture des réels
Sans format
Il y a 18 espaces qui seront réservées pour l’écriture d’un nombre réel. Un nombre réel
sera écrit sous la forme exponentielle.
WRITE(Un_Réel[,…]);
WRITELN(Un_Réel[,…]);
Voyons un exemple.
VAR X, Y : REAL;
...
X := 2.4;
Y := 35.2;
WRITELN (X);
WRITE(X,Y);
2.4000000000E+00
2.4000000000E+00 3.5200000000E+01
Explication
– Avec « WRITELN(X); », 18 espaces seront réservées pour l’écriture de la valeur de X.
Le curseur passe ensuite au début de la ligne suivante.
– Avec « WRITE(X,Y) ; », 36 espaces seront réservées pour l’écriture des valeurs de X
et Y.
Note.– Sous la forme exponentielle, les valeurs 2.4 et 35.2 sont présentées comme suit :
2.4 = 2.4 X 100
35.2 = 3.52 X 101
Avec format
L’écriture est effectuée de droite à gauche.
WRITE(Un_Réel:E:D [,…]);
WRITELN(Un_Réel:E:D[,…]);
32
Voyons un exemple.
VAR X, Y : REAL;
...
X := 2.4;
Y := 35.2;
WRITELN (X:4:1);
WRITE(X:6:1,Y:10:2);
2.4
2.4
35.20
(Avec une décimale)
(Avec dix espaces réservées pour la valeur
de Y avec 2 décimales)
Explication
– Avec « WRITELN(X:4:1); », quatre espaces seront réservées pour l’écriture de la
valeur de X avec une décimale. Le curseur passe ensuite au début de la ligne
suivante.
– Avec « WRITE(X:6:1,Y:10:2); », six espaces seront réservées pour l’écriture de la
valeur de X avec une décimale et dix espaces seront réservées pour l’écriture de la
valeur de Y avec deux décimales.
4.3.3 Écriture des caractères
Sans format
WRITE(Un_Caractère[,….]);
WRITELN(Un_Caractère[,….]);
Voyons un exemple.
VAR C1, C2 : CHAR;
...
C1 := #97;
(Caractère « a »)
C2 := 'b';
WRITELN(C1);
WRITE(C1,C2);
a
ab
Explication
– Avec « WRITELN(C1); », la valeur de C1 est écrite à partir de la première colonne. Le
– Avec « WRITE(C1,C2); », la valeur de C1 est écrite à la première colonne, puis la
valeur C2 sera écrite à la deuxième colonne.
33
Avec format
WRITE(Un_Caractère:E[,….]);
WRITELN(Un_Caractère:E[,….]);
Voyons un exemple.
VAR C1, C2 : CHAR;
...
C1 := #97;
(Caractère « a »)
C2 := 'b';
WRITELN(C1:4);
WRITE(C1,C2:5);
a
a b
Explication
– Avec « WRITELN(C1:4); », quatre espaces seront réservées pour l’écriture de la
valeur de C1. Le curseur passe ensuite au début de la ligne suivante.
– Avec « WRITE(C1,C2:5); », la valeur de C1 sera écrite à la première colonne, puis
cinq espaces seront réservées pour l’écriture de la valeur C2.
Note.– On peut écrire un caractère en spécifiant son ordre dans la table ASCII grâce à la
fonction « CHR ». Voyons un exemple
...
WRITE(CHR(97));
À l’écran sera affiché : a
4.3.4 Écriture des booléens
Sans format
WRITE(Un_Booléen[,….]);
WRITELN(Un_Booléen[,….]);
Voyons un exemple.
VAR B1, B2 : BOOLEAN;
...
B1 := FALSE;
B2 := TRUE;
WRITELN(B1);
WRITE(B1, B2);
FALSE
FALSETRUE
34
Explication
– Avec « WRITELN(B1); », la valeur de B1 est écrite à partir de la première colonne. Le
– Avec « WRITE(B1,B2); », la valeur de B1 sera écrite à partir de la première colonne,
puis la valeur B2 sera écrite à partir de la sixième colonne.
Avec format
WRITE(Un_Booléen:E[,….]);
WRITELN(Un_Booléen:E[,….]);
Voyons un exemple.
VAR B1, B2 : BOOLEAN;
...
B1 := FALSE;
B2 := TRUE;
WRITELN(B1:6);
WRITE(B1, B2:5);
FALSE
FALSE TRUE
Explication
– Avec « WRITELN(B1:6); », six espaces seront réservées pour l’écriture de la valeur
B1. Le curseur passe ensuite au début de la ligne suivante.
– Avec « WRITE(B1,B2:5); », la valeur de B1 sera écrite à partir de la première
colonne, puis cinq espaces seront réservées pour écrire la valeur de B2.
4.3.5 Écriture des chaînes de caractères
Sans format
WRITE(Un_Chaîne[,….]);
WRITELN(Un_Chaîne[,….]);
Voyons un exemple.
VAR C1, C2 : STRING[10];
...
C1 := 'Je';
C2 := 'mange';
WRITELN(C1);
WRITE(C1, C2);
Je
Je mange
35
Explication
– Avec « WRITELN(C1); », la valeur de C1 est écrite à partir de la première colonne. Le
– Avec « WRITE(C1,C2); », la valeur de C1 sera écrite à partir de la première colonne,
puis la valeur de C2 sera écrite à partir de la troisième colonne.
Avec format
WRITE(Une_Chaîne:E[,….]);
WRITELN(Une_Chaîne:E[,….]);
Voyons un exemple
VAR C1, C2 : STRING[10];
...
C1 := 'Je';
C2 := 'mange';
WRITELN(C1:4);
WRITE(C1,C2:6);
Je
Jemange
Explication
– Avec « WRITELN(C1:4); », quatre espaces seront réservées pour l’écriture de la
valeur de C1. Le curseur passe ensuite au début de la ligne suivante.
– Avec « WRITE(C1,C2:6); », la valeur de C1 sera écrite à partir de la première
colonne, puis six espaces seront réservées pour l’écriture de la valeur de C2.
4.3.6 Écriture des constantes
L’écriture des constantes est identique à l’écriture des :
– Entiers
(si la constante est un entier)
– Réels
(si la constante est un réel)
– Caractères
(si la constante est un caractère)
– Booléens
(si la constante est une booléenne)
– Chaîne de caractères
(si la constante est une chaîne)
5.
LES TABLEAUX ET LES ENREGISTREMENTS
5.1
Les tableaux
36
Nous vous rappelons qu’un tableau est une structure comprenant un nombre fixe
d’éléments de même type, répondant à un nom collectif. Ces éléments peuvent être de
type Entier, Réel, Caractère, Booléen ou autre.
Un paramètre très important d’un tableau, c’est sa taille, qui n’est que le nombre
d’éléments qu’il peut contenir. La taille d’un tableau est limitée par la capacité de
mémoire de l’ordinateur utilisé.
5.1.1 Les tableaux à une dimension
Un tableau à une dimension est une structure linéaire dans laquelle chaque élément est
repéré par un seul indice. On l’appelle aussi un vecteur, d’où le mot clé ARRAY utilisé en
PASCAL pour le déclarer.
EXEMPLE 5.1
PROGRAM Tableau1;
(* Ce programme utilise un tableau à une dimension. *)
USES
FORMS;
{$R *.RES}
TYPE PetitTableau = ARRAY [1 .. 5] of REAL;
VAR Montantachat : PetitTableau;
BEGIN
Montantachat[1] := 55.6;
WRITELN(Montantachat[1]:5:2);
READLN;
END.
5.1.1 Les tableaux à deux dimensions
Le tableau à deux dimensions est une structure de données dans laquelle chaque élément
est repéré par deux indices : un indice indiquant le numéro de la ligne et un autre
indiquant le numéro de la colonne. C’est donc un vecteur dont chacun des éléments ou
composantes est lui-même un vecteur, d’où leur appellation équivalente de matrice dans
laquelle l’élément auquel on se réfère se trouve à l’intersection de la ligne et de la colonne
spécifiées par les indices.
37
EXEMPLE 5.2
PROGRAM Tableau1;
(* Ce programme utilise un tableau à deux dimensions. *)
USES
FORMS;
{$R *.RES}
TYPE PetitTableau = ARRAY [1 .. 3, 1.. 3] of CHAR;
VAR Tentative : PetitTableau;
BEGIN
Tentative[1, 1] := 'B';
Tentative[2, 1] := 'n';
Tentative[1, 3] := 'u';
Tentative[3, 2] := 'o';
Tentative[3, 1] := 'r';
Tentative[3, 3] := 'j';
WRITELN(Tentative[1, 1]);
READLN;
END.
EXEMPLE 5.3
PROGRAM Tableau;
(*Ce programme permet d’entrer cinq noms et prénoms dans deux
(*tableaux et d’imprimer cette liste*)
USES
FORMS;
{$R *.RES}
CONST
NombreMax = 5;
TYPE
TabNom = ARRAY[1..NombreMax] of STRING[15];
TabPrenom = ARRAY[1..NombreMax] of STRING[15];
VAR
Nom : TabNom;
Prenom : TabPrenom;
i : INTEGER;
BEGIN
WRITELN('Nom
Prénom
');
FOR i := 1 TO NombreMax DO
READLN(Nom[i],Prenom[i]);
WRITELN('Liste de noms');
WRITELN;
WRITELN('Nom
Prénom
WRITELN(Nom[i],Prenom[i]);
READLN;
END.
5.2
38
');
Les enregistrements
Un enregistrement (RECORD) ou article est une structure de données composée d’un
ensemble d’éléments qui ne sont pas nécessairement du même type, appelés champs, et
qui sont manipulés comme un tout. Les champs peuvent être de type Entier, Réel,
Caractère, Booléen, Tableau, Chaîne de caractères, Intervalle, Énumération, Ensemble et
autre.
La déclaration d’une constante de type enregistrement (RECORD) s’effectue en spécifiant
l’identificateur et la valeur de chaque champ. Les éléments de contenu des différents
champs doivent être séparés les uns des autres par des points-virgules, et les valeurs des
enregistrements doivent être encadrées par des parenthèses.
EXEMPLE 5.4
PROGRAM Record1;
(*Ce programme permet d’entrer cinq noms dans un type *)
(*de données Enregistrement et d’imprimer cette liste de noms.*)
USES
FORMS;
(* Déclaration du type Enregistrement *)
CONST Nombre = 6;
TYPE
Etudiant = RECORD
Nom, Prenom : STRING[15];
END;
(* Déclaration des variables globales *)
VAR Liste : ARRAY[1..5] OF Etudiant;
x, y : INTEGER;
BEGIN
FOR Y := 1 TO nombre DO
BEGIN
WRITE('Entrez le prénom de l''étudiant ');
READLN(liste[Y].Prenom);
WRITE('Entrez le nom de l''étudiant ');
READLN(Liste[Y].Nom);
END;
39
(* Imprime les lignes une à une *)
FOR x := 1 TO nombre DO
BEGIN
WRITE('Prénom', Liste[x].Prenom:16);
WRITELN(' Nom ', Liste[x].Nom:15);
END;
END.
5.3
Les pointeurs
Toute information traitée par l’ordinateur réside à une certaine adresse dans la mémoire.
Un pointeur fait référence à l’adresse de la mémoire où cette information est stockée.
C’est donc une variable dynamique dont le contenu est lui-même une adresse. Un
pointeur P qui ne renvoie à aucune autre adresse prend la valeur nulle (NIL); on dit, dans
ce cas, que P ne pointe sur aucun élément.
EXEMPLE 5.5
PROGRAM Project1;
USES FORMS;
TYPE
Typeadresse = RECORD
No : STRING;
Rue : STRING;
Ville : STRING;
Province : STRING;
Codepostal : STRING;
END;
Pointeuradresse = ^Typeadresse;
{$R *.RES}
VAR
Adresse : Pointeuradresse;
BEGIN
NEW(Adresse);
Adresse^.No := '1200';
Adresse^.Rue := 'Street';
Adresse^.Ville := 'Bonne Ville';
Adresse^.Province := 'Quebec';
Adresse^.Codepostal := 'HOH 0H0';
Writeln('Son adresse : ');
WRITELN(Adresse^.No, ' ', Adresse^.Rue, ' ');
WRITELN(Adresse^.Ville,' ',Adresse^.Province);
WRITELN(Adresse^.Codepostal);
DISPOSE(Adresse);
READLN;
END.
40
6.
LES STRUCTURES DE CONTRÔLE
6.1
Instruction IF. . THEN . . . ELSE
L'expression doit fournir un résultat du type standard Booléen. Si l’expression produit la
valeur TRUE, l’instruction suivant le mot réservé THEN est exécutée.
Si l’expression produit la valeur FALSE et qu’une partie ELSE est présente, l’instruction
suivant le mot clé ELSE est exécutée; s’il n’y a pas de partie ELSE, l’exécution se poursuit
par l’instruction suivant le IF.
EXEMPLE 6.1
PROGRAM DECISION;
(* Utilisation de la boucle IF .. THEN … ELSE.*)
USES
FORMS;
VAR A, B : INTEGER;
{$R *.RES}
BEGIN
WRITE ('Entrez un nombre A: ');
READLN(A);
WRITE('Entrez un nombre B :');
READLN(B);
IF A < B THEN
B := A
ELSE
A := B;
WRITE('A = ', A, ' , B = ', B);
END.
Exécution
A
B
56
56
Expression
Entrez un nombre A : 56
Entrez un nombre B : 56
A = 56 ,
B = 56
41
EXEMPLE 6.2
PROGRAM Exemple2;
(*Ce programme permet de calculer la surface ou le périmètre*)
USES
FORMS;
CONST Pi = 3.1416;
VAR R : REAL; (*Rayon*)
C : CHAR; (*Choix*)
{$R *.RES}
BEGIN (*Programme principal*)
R := 2.5;
(*Choix S pour calculer la surface ou
P pour calculer le périmètre*)
WRITE('Votre choix (S, P) : ');
READLN(C);
IF C IN ['S', 's', 'P', 'p'] THEN
BEGIN
IF C IN ['S', 's'] THEN
WRITE ('Surface : ', (Pi*R*R):5:2)
ELSE
WRITE ('Périmètre : ', (2*Pi*R):5:2);
END
ELSE
WRITE ('Choix invalide ....');
READLN;
END.
Exécution
Surface :
Périmètre :
19.65
15.71
EXEMPLE 6.3
PROGRAM Exemple;
(*Utilisation de l’instruction IF .. THEN … ELSE*)
USES
FORMS;
VAR X, Y, Z, V1, V2 : INTEGER;
{$R *.RES}
X := -234;
Y := 492;
Z := 757;
IF (X >= Y) AND (X >= Z) THEN
42
BEGIN
V2 := X;
IF Y >= Z THEN
V1 := Z
ELSE
V1 := Y;
END (* Fin du IF*)
ELSE
BEGIN
IF (X >= Y) AND (X < Z) THEN
BEGIN
V2 := Y;
V1 := Z;
END (*Fin du IF*)
ELSE
BEGIN
IF (X < Y) AND (X >= Z) THEN
BEGIN
V2 := Y;
V1 := Z;
END (*Fin du IF*)
ELSE
BEGIN
IF (X < Y) AND (X < Z) THEN
BEGIN
V1 := X;
IF Y >= Z THEN
V2 := Y
ELSE
V2 := Z;
END; (*Fin du IF*)
END; (*Fin du ELSE*)
WRITELN('La valeur de V1 est : ', V1);
WRITELN('La valeur de V2 est : ', V2);
END.
Exécution
La valeur de V1 est : -234
La valeur de V2 est : 757
6.2
43
Instruction CASE .. OF
L’instruction CASE comprend une expression (le sélecteur) et une liste d’instructions,
chacune étant « préfixée » par une ou plusieurs constantes (les constantes de cas), ou par
le mot ELSE. Le sélecteur doit être d’un type scalaire; de ce fait, les types Chaîne de
caractères ne sont pas des types de sélecteurs valides. Les constantes de cas doivent être
uniques et d’un type scalaire compatible avec le type du sélecteur.
EXEMPLE 6.4
PROGRAM Exercice1;
(*Ce programme permet de convertir la note d’un étudiant.*)
USES
FORMS;
VAR Intra, Final, Travaux : REAL;
Note : BYTE;
Resultat : STRING[20];
{$R *.RES}
BEGIN
Intra := 73.5;
Final := 81;
Travaux := 65.5;
Note := ROUND((Intra*0.3) + (Final*0.4) + (Travaux*0.3));
CASE Note OF
85 .. 100 :Resultat := 'A';
75 .. 84 : Resultat := 'B';
65 .. 74 : Resultat := 'C';
50 .. 64 : Resultat := 'D';
ELSE
Resultat := 'E';
END;
WRITELN('La note finale est :', Resultat);
READLN;
END.
Exécution
La note finale est : C.
6.3
Boucle WHILE .. DO
L’instruction WHILE .. DO contient une expression dont l’évaluation contrôle l’exécution
répétitive d’une instruction (simple ou composée).
44
L’expression doit produire un résultat de type Booléen. Elle est évaluée avant l’exécution
de la séquence. La séquence est ensuite exécutée de façon répétitive tant que l’expression
renvoie la valeur TRUE. Si l’expression renvoie la valeur FALSE avant la première
exécution de la séquence d’instructions, cette dernière n’est jamais exécutée.
EXEMPLE 6.5
PROGRAM Exercice;
(*Calculer la somme des 10 premiers chiffres : *)
(*Somme = 1+ 2 + 3 + ... + 10*)
USES
FORMS;
VAR Somme, Chiffre : Integer ;
(*Programme principal*)
{$R *.RES}
BEGIN
Somme := 0;
Chiffre := 1;
WHILE Chiffre <= 10 DO
BEGIN
Somme := Somme + Chiffre;
Chiffre := Chiffre + 1;
END;
WRITE('La somme est : ', Somme);
READLN;
END.
Exécution
Somme
Chiffre
55
11
Expression
FALSE
La somme est : 55
45
EXEMPLE 6.6
PROGRAM Exercice2;
(* Affiche un triangle rempli d’étoiles s’étendant sur 7 lignes.*)
USES
FORMS;
VAR Ligne, Colon : INTEGER;
{$R *.RES}
Ligne := 1;
WHILE ligne <= 7 DO
BEGIN
Colon := 1;
WHILE Colon <= Ligne DO
BEGIN
WRITE ('*');
Colon := Colon + 1;
END; (* Fin du WHILE *)
Ligne := Ligne + 1 ;
WRITELN;
END;
END.
Exécution
*
**
***
****
*****
******
*******
EXEMPLE 6.7
PROGRAM Exercice 4;
(* Calcul de la valeur Z*)
USES
FORMS;
VAR X, Y, Z, I : INTEGER;
{$R *.RES}
BEGIN (*PROGRAMME principal*)
X := 3;
Y := 4;
46
I := 1;
Z := 1;
WHILE I <= Y DO
BEGIN
Z := Z * X;
I := I + 1;
END;
WRITELN(' La valeur de Z est : ',Z);
END.
Exécution
La valeur de Z est : 81.
EXEMPLE 6.8
PROGRAM Exercice5;
(* Calcul des valeurs L, P, K*)
USES
FORMS;
VAR K, P, L : INTEGER;
{$R *.RES}
K := 3;
P := 6;
L := 5;
WHILE P < 10 DO
BEGIN
L := L * 10;
P := P + 2;
K := L + P;
END;
WRITELN(' La valeur de L est : ',L);
WRITELN(' La valeur de P est : ',P);
WRITELN(' La valeur de K est : ',K);
READLN;
END.
Exécution
La valeur de L est : 500
La valeur de P est : 10
La valeur de K est : 510.
6.4
47
Instruction WHILE NOT EOF(fichier) DO
L’instruction WHILE NOT EOF(fichier) DO est utilisée pour la lecture de fichiers texte.
Elle permet de lire, dans le cas de fichiers texte, une ou plusieurs valeurs dans une ou
plusieurs variables. La fonction EOF détermine si la position en cours du pointeur se
trouve à la fin de fichier
Explication de l’utilisation des instructions READ et EOF avec une variable de type
Chaîne.
READ lit tous les caractères jusqu’au marqueur suivant de fin de ligne (non compris) ou
jusqu’à ce que EOF (F) passe à TRUE; la lecture achevée, la procédure ne passe pas à la
ligne suivante. La chaîne résultante est tronquée si elle est de taille supérieure à la taille
maximale de variable chaîne.
À l’issue du premier READ, chaque READ suivant détecte le marqueur fin de ligne et
renvoie une chaîne de taille nulle. Il est bon d’utiliser plusieurs appels à READLN pour
lire des valeurs successives de type Chaîne.
Explications de l’utilisation des instructions READ et EOF avec une variable de type
Entier ou Réel.
READ passe outre les espaces, les tabulations et les marqueurs de fin de ligne qui
précèdent la chaîne numérique. Si la chaîne numérique ne respecte pas le format attendu,
une erreur d’E/S se produit ; sinon, la valeur est affectée à la variable.
Le READ suivant recommence à partir de l’espace, de la tabulation ou du marqueur de fin
de ligne qui a terminé la chaîne numérique précédemment lue.
EXEMPLE 6.9
PROGRAM Tableau1while;
(*Ce programme permet de lire dans le fichier 'DONNEE.DTA' *)
(*et d’imprimer cette liste de noms*)
USES
FORMS;
{$R *.RES}
CONST
NombreMax = 30;
TYPE
TabNom = ARRAY[1..NombreMax] of STRING[15];
TabPrenom = ARRAY[1..NombreMax] of STRING[15];
VAR
Nom : TabNom;
Prenom : TabPrenom;
i : INTEGER;
Fichier : TEXT;
Cmptligne : INTEGER;
48
BEGIN
ASSIGN(Fichier,'TP4_3.dta');
RESET(Fichier);
Cmptligne := 1;
i := 1;
WRITELN('Nom
Prénom
');
WHILE NOT EOF(Fichier) DO
BEGIN
READLN(Fichier,Nom[i],Prenom[i]);
CmptLigne := CmptLigne + 1;
i := i + 1;
END;
IF Cmptligne > NombreMax THEN
Cmptligne := NombreMax;
WRITELN('Liste de noms');
WRITELN;
WRITELN('Nom
Prénom
');
WRITELN(Nom[i],Prenom[i]);
CLOSE(Fichier);
READLN;
END.
6.5
Boucle REPEAT. . UNTIL
REPEAT permet de répéter une instruction ou une série d’instructions jusqu’à ce qu’une
condition soit vraie (TRUE). Elle commence par le mot réservé REPEAT et se termine par
le mot réservé UNTIL, suivi de la condition évaluée. Cette condition est toujours une
expression booléenne.
EXEMPLE 6.10
PROGRAM Exercice1;
( *Exemple d’utilisation de la boucle REPEAT UNTIL* )
USES
FORMS;
VAR Ligne, Colonne : INTEGER;
{$R *.RES}
Ligne := 1;
REPEAT
Colonne := Ligne;
REPEAT
WRITE(Colonne);
49
Colonne := Colonne + 1;
UNTIL Colonne > 4 ;
Ligne := Ligne + 1;
WRITELN;
UNTIL Ligne > 4;
READLN;
END.
Exécution
1234
123
12
1
EXEMPLE 6.11
PROGRAM REPEATUNTIL1;
(*Calculer le nombre d’années pour
terminer de payer un prêt hypothécaire
de 50 000 $ avec un taux d’intérêt annuel de
7,5 % sachant que le montant
déposé annuellement est de 8,200$*)
USES
FORMS;
VAR Pret, Montant, Taux, Interet : REAL;
NbAn :INTEGER; (* Nombre d’années*)
(* à calculer*)
{$R *.RES}
Pret := 50000;
Taux := 0.075;
Montant := 8200;
NbAn := 0;
REPEAT
NbAn := NbAn + 1;
Interet := Pret * Taux;
Pret := Pret + Interet;
Pret := Pret - Montant;
UNTIL Pret <= 0;
WRITE ('Nombre d''années est : ', NbAn);
READLN;
END.
Exécution
Nombre d’années est : 9.
50
EXEMPLE 6.12
PROGRAM REPEATUNTIL1;
(* Exemple d’utilisation de la boucle REPEAT .. UNTIL *)
USES
FORMS;
VAR X, N : INTEGER;
{$R *.RES}
X := 0;
N := 0;
REPEAT
X := X + 1;
IF X MOD 2 = 0 THEN
N := N +1;
UNTIL X > 20;
WRITELN(' Valeur de N est : ' , N);
READLN;
END.
Exécution
La valeur de N est : 10.
EXEMPLE 6.13
PROGRAM Exercice5;
(* Exemple d’utilisation de la boucle REAPET .. UNTIL *)
USES
FORMS;
CONST Max = 0.875;
VAR Terme: INTEGER;
Somme : REAL;
{$R *.RES}
Somme := 0;
Terme := 2;
REPEAT
Somme := Somme + (1/Terme);
Terme := Terme * 2;
UNTIL Somme >= Max;
WRITELN('La valeur finale de Terme est : ',Terme);
READLN;
END.
Exécution
La valeur finale de Terme est : 16.
6.6
51
Boucles FOR
6.6.1 FOR .. TO
L’instruction FOR provoque l’exécution répétitive d’une instruction (simple ou
composée) parallèlement à l’incrémentation ou la décrémentation du contenu d’une
variable de contrôle.
EXEMPLE 6.14
PROGRAM FORTO;
(*Calculer la factorielle d’un nombre entier
positif : N! = 1 x 2 x ... x n
exemple : 4! = 1 x 2 x 3 x 4 = 24*)
USES
FORMS;
VAR N, F, I : INTEGER;
{$R *.RES}
N := 4;
F := 1;
FOR I := 1 TO N DO
F := F * I;
WRITELN('La factorielle de 4 est : ',F);
READLN;
END.
Exécution
La factorielle de 4 est : 24.
6.6.2 FOR .. DOWNTO
Avec le mot réservé DOWNTO, le contenu de la variable de contrôle est décrémenté de 1 à
chaque répétition. Si la valeur initiale est inférieure à la valeur courante de la variable de
contrôle, l’instruction n’est pas exécutée.
EXEMPLE 6.15
PROGRAM DOWTO1;
(* Exemple d’utilisation de DOWNTO *)
USES
FORMS;
VAR J, I : INTEGER;
{$R *.RES}
52
FOR I := 1 TO 3 DO
BEGIN
FOR J := 3 DOWNTO 1 DO
BEGIN
IF J > I THEN
WRITE (I:2)
ELSE
WRITE(J:2);
END;
WRITELN;
END;
READLN;
END.
Exécution
111
221
321
7.
53
LES PROCÉDURES
PASCAL permet de décomposer un programme en plusieurs sous-programmes. La
décomposition offre les avantages suivants :
– Évite la duplication des mêmes séquences d’instructions dans un même programme.
– Détecte plus facilement les erreurs logiques.
– Comprend et s’adapte plus facilement aux besoins des usagers.
– Est accessible à partir de plusieurs endroits du programme.
Il existe deux sortes de sous-programmes :
– Les procédures
– Les fonctions
Une procédure est une structure de programme autonome incluse dans un programme. Son
diagramme syntaxique se présente comme suit :
PROCEDURE-En-tête
Bloc d’instructions
L’en-tête est constitué du nom de la procédure et d’une liste de paramètres formels
(optionnelle). Le bloc d’instructions est constitué d’une partie de la déclaration et d’une
liste d’instructions. La liste d’instructions doit être encadrée par un « BEGIN » et un
« END ». Les procédures se retrouvent entre les déclarations globales et le début (BEGIN)
du corps du programme principal. Le programme de l’exemple 7.1 est un exemple de
programme qui comporte une procédure
EXEMPLE 7.1
PROGRAM Procedure2;
Programme principal
USES
FORMS;
VAR Pret, Montant, Taux, Interet : REAL;
{$R *.RES}
PROCEDURE CALCUL;
VAR NbAn : INTEGER;
Déclaration globale
du programme
Procédure
En-tête de la procédure
Déclaration locale de la procédure
BEGIN
Liste d’instructions de la procédure
NbAn := 0;
REPEAT
NbAN := NbAn + 1;
Interet := Pret * Taux;
Pret:= Pret + Interet;
Pret := Pret - Montant;
UNTIL Pret <=0;
WRITE('Le nombre d''années est de : ',NbAn);
END;
54
BEGIN
Début du
WRITE('Ecrire le montant du prêt :');
programme principal
READLN ( Pret);
WRITE('Entrez le taux : Exemple 0.065 = 6.5% : ');
READLN (Taux);
WRITE('Écrire le montant que vous voulez payer à chaque année ');
READLN(Montant);
CALCUL;
READLN;
END.
Fin du programme principal
7.1
Variables globales
Les variables globales sont des variables qui sont déclarées dans la partie de la déclaration
globale du programme et qui sont connues partout dans le programme; c’est la même
chose pour les constantes globales.
Dans l’exemple précédent, Pret, Montant, Taux, Interet sont des variables globales.
7.2
Variables locales
Les variables locales sont des variables qui ne sont connues qu’à l’intérieur de la
procédure où elles sont déclarées. Elles ne sont pas connues dans le bloc du programme
principal et elles n’existent qu’au moment où la procédure est appelée.
Dans l’exemple précédent, NbAn est une variable locale dans la procédure CALCUL.
7.3
Appel de procédure
On appelle une procédure par son nom. De plus, le nombre de paramètres effectifs (à
envoyer) doit être identique au nombre de paramètres formels (à recevoir). Par ailleurs, les
paramètres correspondants doivent être du même type.
Dans l’exemple précédent, « CALCUL » est un appel de procédure.
7.4
Transmission de paramètres
Il y a deux modes de transmission de paramètres : la transmission par valeur (ou par
copie) et la transmission par référence (ou par variable).
– Transmission par valeur. On fournit de l’information à la procédure appelée, mais on
n’a pas besoin du résultat de retour du ou des paramètres. Après être sorti de cette
procédure, ce ou ces paramètres contiendront toujours leurs anciennes valeurs.
Note.– Avant de transmettre un paramètre par valeur, sa valeur doit être connue.
–
55
Transmission par référence. On attend le résultat de retour du ou des paramètres
envoyés. Après être sorti de cette procédure, ce ou ces paramètres prendront la ou les
valeurs les plus récentes.
Important.– On doit introduire le mot « VAR » devant le ou les paramètres dans l’entête de la procédure appelée.
Note.– Avant de transmettre un paramètre par référence, sa valeur n’est pas
nécessairement connue.
EXEMPLE 7.2
PROGRAM Procedure2;
(* Ce programme permet de lire et de calculer la somme de deux nombres
réels en utilisant la décomposition en procédures. *)
USES
FORMS;
{$R *.RES}
VAR R1, R2, Somme : REAL;
(*On attend la valeur de retour*)
PROCEDURE lire (VAR Z : REAL);
BEGIN
WRITE ('Entrez un nombre : ');
READLN(Z);
END;
(*On fournit les valeurs de X et Y et on attend la valeur *)
(* de retour de Somme *)
PROCEDURE Calcul (X, Y: REAL);
BEGIN
Somme := X + Y;
END; (*Fin de la procédure Calcul*)
BEGIN
Lire (R1);
Les valeurs de R1 et de R2 ne sont pas connues
Lire (R2);
avant d'appeler la procédure.
Calcul(R1, R2);
Les valeurs de R1 et R2 sont déjà connues.
WRITELN('Le nombre de R1 est : ',R1:9:2);
WRITELN('Le nombre de R2 est : ',R2:9:2);
WRITELN('Le nombre de la somme est : ',Somme:9:2);
END. (* Fin du programme*)
Note.– Les identificateurs des paramètres à l'appel et les identificateurs des paramètres de
la procédure ne sont pas nécessairement identiques.
Litre (R1)
→
PROCEDURE lire (VAR Z : REAL);
56
EXEMPLE 7.3
PROGRAM Exemple1;
(*Exemple de procédure*)
USES
FORMS;
{$R *.RES}
VAR K, L : BYTE;
PROCEDURE Calcul (A: BYTE; VAR B : BYTE);
BEGIN
A := A * B;
B := B MOD 2;
WRITELN (K, A:3, B:3);
END; (*Fin de la procédure Calcul*)
BEGIN
K := 5;
L := 7;
WRITELN ('Les nombres : ',K , L:3);
Calcul(K, L);
WRITELN ('Les nombres : ',K , L:3);
READLN;
END.
EXEMPLE 7.4
PROGRAM Exercice2;
USES
FORMS;
{$R *.RES}
VAR K , Y: INTEGER;
PROCEDURE P (X : Integer);
PROCEDURE Q (VAR Y : Integer);
BEGIN
Y := SQR(Y);
WRITELN ('Les nombres : ',Y);
END;
BEGIN
Q(X);
X := X + 1;
END; (*Fin du Calcul*)
BEGIN
K := 8;
P(K);
WRITELN ('Les nombres : ',K);
READLN;
END.
57
EXEMPLE 7.5
PROGRAM Procedurecalcul3;
USES
FORMS;
{$R *.RES}
VAR A, B, C: INTEGER;
PROCEDURE Une;
BEGIN
A := 2 * A;
B := A + 5;
END;
PROCEDURE Deux(VAR A, B : Integer);
VAR C : INTEGER;
BEGIN
IF ((B-A) MOD 2 <> 0) THEN
BEGIN
C := A;
A := B;
B := C;
END (*Fin du IF*)
ELSE
B := A;
END;
BEGIN
A := 10;
B := 2;
C := 4;
WRITELN ('Les nombres : ',A:5, B:5, C:5);
Une;
Deux(A,B);
Deux(C,B);
READLN;
END.
8.
58
LES FONCTIONS
PASCAL permet de décomposer un programme en plusieurs sous-programmes. La
décomposition offre les avantages suivants :
– Évite la duplication des mêmes séquences d’instructions dans un même programme.
– Détecte plus facilement les erreurs logiques.
– Comprend et s’adapte plus facilement aux besoins des usagers.
– Est accessible à partir de plusieurs endroits du programme.
Une fonction est une structure de programme autonome incluse dans un programme qui
ressemble en plusieurs points à une procédure. La seule différence réside dans le fait que
la fonction retourne une seule valeur de type simple (Réel, Entier, Caractère, Booléen,
Chaîne des caractères, Énuméré et Intervalle). Le diagramme syntaxique d’une fonction
se présente comme suit :
FUNCTION - en-tête Bloc d’instructions
L’en-tête est constitué du nom de la fonction, d’une liste des paramètres formels
(optionnelle) et d’un type de retour. Le bloc d’instructions doit être constitué d’une partie
de la déclaration et d’une liste d’instructions. La liste d’instructions doit être encadrée
dans un « BEGIN » et un « END ». Les fonctions se retrouvent entre les déclarations
globales et le début (BEGIN) du corps du programme principal.
EXEMPLE 8.0
Structure d’un programme qui comporte une fonction
PROGRAM Fonctionl3;
USES
FORMS;
{$R *.RES}
VAR Utilisateur : REAL;
Programme principal
Déclaration globale
du programme principal
FUNCTION Carre (Entree : REAL) : REAL; L’en-tête de la fonction
CONST Nombre1 = 3.1416;
Déclaration locale de la fonction
VAR Nombre2 : REAL;
BEGIN
Liste d’instructions de la fonction
Nombre2 := Nombre1 * Entree;
Carre := Entree * Entree * nombre2;
END;
BEGIN
Début du
WRITE(Entrez un nombre :');
programme principal
READLN(Utilisateur);
Appel de la fonction
WRITE('Le nombre est : ',carre(Utilisateur));
READLN
END.
Fin du programme principal
8.1
59
Variables globales
Les variables globales sont des variables qui sont déclarées dans la partie de la déclaration
globale du programme et sont connues partout dans le programme; c’est la même chose
pour les constantes globales).
Dans l’exemple précédent, Utilisateur est la variable globale.
8.2
Variables locales
Les variables locales sont des variables qui ne sont connues qu’à l’intérieur de la fonction
où elles sont déclarées. Elles ne sont pas connues dans le bloc du programme principal et
elles n’existent qu’au moment où la fonction est appelée.
Dans l’exemple précédent, Nombre2 est une variable locale dans la fonction CARRE.
8.3
Appel des fonctions
On appelle une fonction par son nom. De plus, le nombre de paramètres effectifs (à
envoyer) doit être identique au nombre de paramètres formels (à recevoir). Par ailleurs, les
paramètres correspondants doivent être du même type.
EXEMPLE 8.1
PROGRAM FUNCTIONfin;
USES
FORMS;
VAR X, Y : INTEGER;
{$R *.RES}
FUNCTION Lire : INTEGER;
VAR Nb : INTEGER;
BEGIN
WRITE ('Entrez un nombre > ');
READLN(Nb);
Lire := Nb;
END;
FUNCTION Moyen (A, Y : LONGINT): REAL;
BEGIN
Moyen := (A + Y) / 2;
END;
BEGIN
Y := Lire;
X := Lire;
WRITE('Moyenne = ', Moyen(Y,X):15:2);
READLN;
END.
9.
60
UNITÉS
Le langage PASCAL Objet pour DELPHI 3 (Borland) supporte des modules
d’instructions compilés séparément et plus connus sous le nom d’unités. Avec les unités,
les instructions sont plus structurées et peuvent être réutilisées dans plusieurs projets.
Dans les projets DELPHI 3, les unités les plus utilisées sont les unités fiches. Elles
contiennent les gestionnaires d’événements et les instructions des fiches des projets.
Cependant, des unités peuvent faire partie du projet sans être associées à des fiches. Vous
pouvez créer et enregistrer une unité, en tant que fichier indépendant, qu’aucun projet
n’utilise. Par exemple, vous pouvez écrire vos propres fonctions, DLL et composants, puis
placer leurs instructions sources dans un fichier à part, qui ne soit associé à aucune fiche.
Qu’une unité soit associée à une fiche ou non, sa structure de base est la même. Les
parties d’une unité sont les suivantes :
– UNIT < identificateur >;
– INTERFACE
– USES < liste des unités>; { facultatif }
{ Déclarations publiques }
– Implémentation
– USES <liste des unités>;
{ facultatif }
{ Déclarations privées }
{ implémentation des procédures et fonctions }
– Initialisation
{ facultatif }
{ code d’initialisation facultatif }
– END;
L’en-tête de l’unité commence par le mot réservé UNIT, suivi du nom de l’unité
(identificateur). L’élément suivant est le mot réservé INTERFACE, qui indique le début de
la partie interface de l’unité; c’est la partie visible pour les autres unités ou applications
qui utilisent celle-ci.
Ce programme utilise une unité et additionne, en utilisant le langage PASCAL Objet pour
DELPHI 3, deux chiffres en cliquant sur un bouton.
Nous utilisons dans ce programme une fiche, l’inspecteur objet, un programme principal
et une unité.pas.
61
CRÉATION D’UNE FICHE
INSPECTEUR OBJET PERMETTANT DE MODIFIER LES CARACTÉRISTIQUES
DE LA FICHE.
62
EXEMPLE D’UN PROGRAMME EN PASCAL OBJET (DELPHI) :
LE PROGRAMME PRINCIPAL (TESTEPROJECT1.DPR)
PROGRAM TesteProject1;
USES
FORMS,
testeunite in 'testeunite.pas' {Form1};
{$R *.RES}
BEGIN
Application.Initialize;
Application.CreateForm(TForm1, Form1);
Application.Run;
END.
L’UNITÉ SOURCE (TESTEUNITE.PAS).
UNIT Testeunite;
INTERFACE
USES
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls;
TYPE
TForm1 = class(TForm)
Edit1: TEdit;
Edit2: TEdit;
Label1: TLabel;
Button1: TButton;
PROCEDURE Button1Click(Sender: TObject);
private
{ Déclarations privées }
PROCEDURE AjouteNombre;
public
{ Déclarations publiques }
END;
VAR
Form1: TForm1;
IMPLEMENTATION
{$R *.DFM}
63
PROCEDURE TForm1.AjouteNombre;
VAR
Valeur1, Valeur2, Total : INTEGER;
BEGIN
Valeur1 := StrtoInt(Edit1.Text);
Valeur2 := StrtoInt(Edit2.Text);
Label1.Caption := IntToStr(Valeur1 + Valeur2);
END;
PROCEDURE TForm1.Button1Click(Sender: TObject);
BEGIN
AjouteNombre;
END;
END.
SOLUTION DU PROBLÈME (1024 + 1024 = 2048) :
BIBLIOGRAPHIE
Guide du développeur Borland DELPHI 3, Borland International, Ireland, 1997.
Guide de l’utilisateur Borland DELPHI 3, Borland International, Ireland, 1997.
Dan Osier, Steve Batson et Steve Grobman, DELPHI 3, Simon & Schuster Macmillan,
Paris, 1997.

INTRODUCTION À LA PROGRAMMATION INF 1200

Transcription

Documents pareils

Correction

Correction

Saint-Maximin

Brignoles

Enregistrement et Fichiers

Polycopie des cours de programmation (Turbo

gestion locative

Mise en Page

Brignoles ZAC Les Consacs (page 1)

discours pour le forum de l`emploi le 13 mai 2014