Vous êtes sur la page 1sur 21

Eléments de base du langage pascal

Généralités
 

Le langage Pascal est un langage de programmation dit évolutif parce qu'il est proche du
langage humain. Il est créé en 1969 à l'école polytechnique de Zurich par NWIRTH. Il a
été conçu pour permettre d'enseigner la programmation comme une science. Sa
conception présente beaucoup d'avantages:

 Il est facile à enseigner et à apprendre.


 Il permet d'écrie des programmes lisibles et structurés.
 Il permet une manipulation facile des données et des fichiers.

Caractéristiques d'un programme Pascal


 

Un programme écrit en Pascal est constitué d'une suite d'instructions qui sont des
phrases du langage.
Un programme Pascal comprend deux parties:
1. L'en-tête: Qui comprend le nom du programme et éventuellement des paramètres.
2. Le corps du programme: Comprend les déclarations et les instructions. Les instructions sont séparées entre
elles par les points virgule (;). Le programme Pascal se termine toujours par un point (.) et il a la forme
suivante:

En-tête [Programme nom([paramètres])


corps du programme:
Déclaration;
Begin;
Instructions;
End.
 

Déclaration
 

La déclaration permet à l'ordinateur de réserver un espace mémoire pour chaque objet.


Elle n'est pas exécutable. On distingue:
 La déclaration d'étiquette.
 La déclaration de constante.
 La déclaration de type.
 La déclaration de variable.
 La déclaration de procédure.
 LA déclaration de fonction.

Déclaration d'étiquette
 

En pascal toute instruction peut être précédée par une étiquette qui identifie de façon
unique chaque instruction.
C'est un entier positif d'au plus 4 chiffres. Tout élément soit être suivi du caractère (:).
On peut débrancher une instruction étiquette à l'aide de l'instruction goto étiquette.
Exemple:
goto 100
x :=1;
100:x:=x+4;
y:=x-2
Pour déclarer une étiquette on fait: Label entier;
Exemple:
Label 10, 12, 10;
 

Déclaration de constante
Une constante est un objet qui ne peut pas changer de valeur lors de l'exécution d'un
programme. Sa déclaration est: const identification = valeur
Exemple:
const Pi=3.14;
onze=11.0;
max=45;
min=-max
 

Déclaration de type
 

Le type d'un objet est l'ensemble dans lequel cet objet prend ses valeurs. On distingue
les types non standard.
Les types non standard sont définis par le programme et ne sont valables dans le
programme qui les utilise.
La déclaration d'un type est le suivante:
type identification=ensemble de valeur;
Exemple:

type semaine=(Lundi, Mardi, Mercredi, Jeudi, Vendredi, Samedi, Dimanche)


sexe=(Masculin, Feminin);
logique=(vraie, faux);
entier=integer;
 

Déclaration de variable
 

Une variable est un objet qui peut changer de valeur lors de l'exécution d'un programme.
On retrouve la déclaration des variables dans tous les programmes.
On déclare une variable de la façon suivante:
var identificateur: type;
Exemple:
var a: interger;
jour: semaine;
 

La partie exécutable
 

C'est la partie la plus important, sans elle le programme ne s'exécute pas. Elle
commence toujours par le mot Begin et se termine toujours part le mot End. Cette partie
est constituée d'une séquence d'instruction exécutable (lecture, écriture, affectation ou
structure de contrôle).
Exemple de programme Pascal:

program suite
(*Ce programme affiche les nombres de 1 à 10*);
var nombre: interger; (*compteur*)
Begin
for nombre := 1 to 10 do
writeln(nombre);
end. (*fin du programme*)
 

Les types de base


 

Ce sont les types standard (qui sont prédéfinis dans l'ordinateur).


On a:

 Le type entier.
 Le type réel.
 Le type caractère.
 Le type booléen.
 Le type chaîne de caractères.

Le type entier
 

Le mot utilisé est integer, tout élément de ce type appartient à l'intervalle [-max int, max
int] où l'identificateur max int fournit la valeur du plus grand entier représentable. Les
nombres que l'on peut représenter sont limités par la taille de l'emplacement mémoire
utilisé pour les codes (2 octets=16bits).
Avec 16 bits on peut représenter les nombres appartenant à l'intervalle [-215; 215-1]=[-
32768;32767]. En complément à 2.
Ainsi donc Max int = 32 767
A partir de cette limitation du type entier le programme est toujours confronté au
problème de dépassement de capacité.
Exemple:

program exemple;
var a, ab: interger;
begin
a := 20000;
b := 2*a;
xriteln('b=', b);
end.
Lors de l'exécution de ce programme l'ordinateur affiche b=-25536. Ce mauvais résultat
provient du fait que les dépassements de capacité dans le cas type entier ne sont jamais
détectés.
Par contre si vous cherchez à écrire une constante comme par exemple 125413 qui ne
peut pas être représenté dans le type entier, vous serrez prévenu par le message de
compilation approprié constant out of rang.
Pour résoudre ce problème le Turbo Pascal dispose du type long int (32bit).
Les opérations possibles avec les objets du type entier sont: l'addition (+); la soustraction
(-); la multiplication (*); la division (div), le modulo (mod).
Les fonctions relatives au type entier sont:

 abs(x)= ; abs(-3)=3 : la valeur absolue


 sqr(x)= ; sqr(3)=9 : le carré
 sqrt(x)= ; sqrt(4)=2.0 : racine carrée

Les types réels


 

Le mot utilisé est real. Un élément de ce type peut s'écrire sous deux formes:

 Sous forme décimal, exemple: 12.43


 Sous forme exponentiel, exemple: 4.25E2

Les nombres réels sont codés sur 6 octets et la technique de codage utilisée permet de
les représenter avec une précision de l'ordre de 1 chiffres significatifs.
On distingue donc l'intervalle 2,9x10-3; 1,7x1038 valeur absolu.
Avec le type réel le déplacement de capacité est détecté. On a un message overglow.
Les opérations relatifs au type réel sont: l'addition (+); la soustraction (-); la multiplication
(*); la division (/).
Les fonctions relatives au type réel sont:

 abs valeur absolue.
 sqr élévation au carré.
 sqrt racine carrée.
 frac la partie fractionnelle, exemple frac(3.05)=0.05

Le type booléen
 

Le mode utilisé est boolean. C'est un ensemble à deux valeurs true, false. Les opérations
utilisées sont:

 and
 or
 not
 xor: le "ou exclusif" (faux lorsque les deux conditions ont la même valeur)

Les opérateurs de comparaison sont:


 = égal
 < inférieur
 > supérieur
 <= inférieur ou égal
 >= supérieur ou égal
 <> différent

Le type caractère
 

Le mot utilisé est char.


C'est un ensemble fini et ordonné de caractère. La nature des caractères dépend de la
machine.
Exemple: 'A'
Les fonctions relatives aux caractéristique sont:

 ord : qui donne la valeur numérique du code de caractère, exemple ord('A')=65


 chr : Donne le caractère ayant le code indiqué, exemple: chr(65)='A' ; chr(66)='B'

Exercice:

Ecrire un programme qui affiche les caractéristiques des codes allant de 1 à 100 et
l'affichage doit se faire de la manière suivant:
le caractère de code 65 est: A
le caractère de code 66 est: B
 

Le type chaîne de caractère


 

Le mode utilisé est string.


Lors de la déclaration d'une chaîne de caractère la longueur de la chaîne doit être
précisée. Elle varie de 1 à 255.
Exemple:

var mot : string[10];


mot := 'papa';
Les opérateurs sur les éléments du type chaîne sont: la concaténation (+ ou
concat); length (qui permet d'obtenir la longueur d'une chaîne de caractère)
copy : permet d'extraire une sous chaîne.
Exemple:

copy('Bonjours', 2,4) = 'onjo'


lentgh('Bonjours') = 7
mot = 'Bonjours'
mot[3] = 'n'
mot[6] = 'u'
Exercice:

Ecrire un algorithme qui lit une chaîne de caractère, il lit la position à partir de laquelle on
doit extraire une sous chaîne de caractère et lit enfin la taille de la sous chaîne obtenue.
 

Instructions simples
 

On distingue:

 L'affectation :=
 La lecture read, readln
 L'écriture write, writeln

Les structures de contrôle


 

Les structures répétitives


 

for compteur := 1 to n do
instruction;

for compteur := n down to 1 do


instruction;

Exemple:
for i := 1 to 10 do
write(i);
Structure "tant que":
while condition do
instruction;

Structure "répéter":
repeat
instruction;
until condition;

Procédures et fonctions

Généralités
En Pascal lorsqu'un programme devient beaucoup plus complexe il est nécessaire
d'utiliser une écriture modulaire permettant de scinder en plusieurs parties ou module le
programme correspondant. Chaque module peut également être décomposé en module
plus élémentaire, il existe deux sortes de module: les procédures et les fonctions.
Généralement une écriture modulaire permet:

 D'éviter de recopier un segment de code plusieurs fois dans un même programme.


 De décomposer un programme ou un module en petits modules, chacun effectuant un travail bien précis.
 De constituer une bibliothèque de sous programme.

Définitions
Fonction: C'est une entité qui calcule un résultat unique en fonction d'un ou de plusieurs
paramètres. La valeur calculée est mise à la disposition de l'utilisateur par l'intermédiaire
du nom de la fonction, qui est une variable d'un type donné: celui de la valeur calculée.
Procédure: C'est une entité pouvant calculer et mettre à la disposition de l'utilisateur
plusieurs valeurs ou aucune. Une procédure ou une fonction peut comporter toutes les
parties d'un programme principal.

Déclaration
Les fonctions et les procédures sont déclarées juste après la déclaration des variables.
Déclaration d'une procédure
procedure nom([liste des paramètres]);
déclaration des variables locales;
Begin
corps de la procédure;
end;

Déclaration de la fonction
function nom([paramètres]): type;
déclaration des variables;
begin
corps de la fonction;
nom := valeur calculée;
end;
Exemple 1:

Ecrivons une procédure qui permet de lire un nombre strictement positif.


procedure Lecture(var a: real);
begin
write('Entrez un nombre positif');
repeat
read(a);
until a>0;
end;
Exemple 2:

Ecrivons une fonction booléenne qui est fausse lorsque le nombre est négatif, vraie
lorsque le nombre est positif.
function Positif(b: real):boolean;
begin
if (b<0) then
Positif := false;
else
if (b>0) then
Positif := true;
else
write('Ce nombre est nul');
end;
Exemple 3:

Ecrivons un programme qui permet de lire deux nombres qui calcule et affiche la somme
et la moyenne de ses nombres.
program calcul;
var nombre1, nombre2, S, M: real;

Procedure Lecture(var a, b: real);


begin
read(a);
read(b);
end;

function somme(x, y: real): real


begin
somme := x+y;
end;

function moyenne(i, j: real):real;


begin
moyenne := (i+j)/2;
end;

begin
write('Entrez deux nombres');
Lecture(nombre1, nombre2);
S := somme(nombre1, nombre2);
M := moyenne(nombre1, nombre2);
writeln('La somme est ', S);
write('La moyenne est ', M);
readln;
end.
Passage de paramètre
On distingue les effectifs et les paramètres formels:

 Un paramètre formel est un paramètre utilisé dans la définition d'un sous-programme.


 Un paramètre effectif ou réel ou actuel est un paramètre utilisé lors de l'appel d'un sous-programme,
exemple: nombre1 et nombre2

Le paramètre actuel doit être compatible au paramètre formel correspondant (doit être de
même type).
Un paramètre peut être:

 Paramètre d'entré c'est-à-dire qu'il fournit les données au sous-programme, exemple: x, y


 Paramètre de sortie c'est-à-dire qu'il contient le résultat à la fin du déroulement du sous-programme,
exemple: a, b
 Paramètre d'entrée sortie c'est-à-dire qu'il joue deux rôles: le rôle de paramètre d'entrée et le rôle de
paramètre de sortie.

Les paramètres d'un sous-programme peuvent être transmis sous plusieurs formes. Les
plus courant sont: la passage par valeur et le passage par adresse.

Passage par valeur


Il concerne les paramètres d'entrée. Lors du passage par valeur toute modification de la
variable formelle n'affecte pas la variable actuelle correspondante.
Les paramètres transmis par valeur ne sont pas précédés par le mot var.

Le passage par adresse


Encore appelé passage par référence, il concerne les paramètres de sortie. Lors du
passage par adresse, les paramètres sont des alias des paramètres actuels
correspondants, c'est-à-dire qui partage le même emplacement mémoire.
Toute action effectuée sur le paramètre formel affecte le paramètre actuel correspondant.
Les paramètres transmis par adresse sont précédés par le mot var
Exercice 1:

program X

procedure A(i, j: integer);


begin
.
.
.
.
.
end;

procedure B(i, j: real);


begin
.
.
.
.
.
end;
Est-ce que ce program X est possible ou pas?
Exemple 1:

Ecrire un programme qui fait appel à une procédure pour permuter le contenu de deux
variables. Les valeurs des deux variables à permuter sont lues par le programme
principal.

program Exemple1

procedure Permuter(var a, b: real);


var c: real;
begin
c := a;
a := b;
b := c;
end;

begin
writeln('Entrez deux nombres');
write('X= '); readln(x);
write('Y= '); readln(y);
Permuter(x, y);
writeln('Le resultat est: ');
write('X= ', x);
write('Y= ', y);
end.
Exemple 2:

Ecrire un programme qui fait appel à une fonction pour déterminer la plus grande valeur
entre deux variables.

program exemple2
var nbre1, nbre2, G: interger;
function plusgrand(x, y: interger): interger
begin
if (x>y) then
plusgrand := x;
else
plusgrand := y;
end;

begin
writeln('Entrez deux nopmbres');
read(nbre1);
read(nbre2);
G := plusgrand(nbre1, nbre2);
writeln(le plus grand est ', G);
end.

La portée des variables


On distingue en général deux types de variables: les variables locales et les variables
globales.

 La variable locale ou privée: Elle est déclarée immédiatement après l'en-tête de la procédure.
Une variable locale peut être globale pour une autre procédure.
Exemple:
procedure A()
var x, y: type
procedure B()
var i, j: type
fin
fin
 La variable globale publique: Elle est déclarée après les étiquettes, les constantes, les types et avant toute
déclaration des procédures.

Exemple:
program
label
const
type
var
procedure

Chaque sous-programme ne connaît que ses variables locales et ses variables globales.
Mais le programme principal connaît uniquement les variables globales.
Exemple:

program X
var z, t: type

procedure A()
var x, y: type

procedue B()
var i, j: type
fin

fin

fin

Types structures

Les tableaux
Un tableau est une structure de données composée de plusieurs éléments de même
type. Chaque élément du tableau est repéré par son indice dans le tableau. L'indice peut
être un type énuméré:

 Entier
 Caractère
 Semaine: Lundi; Mardi; Mercredi; Jeudi; Vendredi; Samedi; Dimanche

Exemple pratique:

const max=100
type semaine = (Lun, Mar, Mer, Jeu, Ven, Sam, Dim)
vecteur1 = tableau[1..max] d'entier
vecteur2 = tableau['a'..'z'] de réel
vecteur3 = tableau[semaine] booléen
pour i=1 à max faire
pour k=Lun à Dim faire
De façon générale, un tableau peut avoir une ou plusieurs dimensions.

Déclaration d'un tableau:


type nom = array[indice1, indice2, ..., indicen] of type element
Exemple:

type
vecteur1 = array[1..12] of integer;
vecteur2 = array[1..5; 1..10] of integer;
vecteur3 = array[1..10; 'a'..'x'] of real;
 

Manipulation d'un tableau


En Pascal la manipulation globale d'un tableau n'est autorisée qu'au niveau de l'affection.
Le reste des opérations s'effectuent case par case.
Exemple 1:

var V, V1: vecteur1


V := V1
Exemple 2: Pour la lecture

for i := 1 to 12 do
read(V1[i]);

Pour l'affichage:
for i := 1 to 12 do
write(V1[i]);
Exemple 3:

for i := 1 to 5 do
for j := 1 to 10 do
read(V[i,j]);
end;
end;
 

Les enregistrements
 
 

Un enregistrement ou "record" en Pascal est défini par un ensemble de données


appelées champs. Les champs sont les données élémentaires ou composés et peuvent
être de type différent.
 

Déclaration
 

type
nom = record
champ1 : type1;
champ2 : type2;
. . . . . . . . . . . . . .
champn : typen;
end;
Exemple:

Déclarons le type personne


type
personne = record
code : string[7];
Exemple:

type
personne = record
code : string[7];
nom : string[20];
prenom : string[20];
masculin : boolean;
nombre_enfant : 0..15;
end;
var employe, homme : personne;

Les fichiers

Généralités
Un fichier est une collection d'information structurée en unité d'accès appelé
enregistrement.
Un fichier est toujours enregistré dans un support externe à la mémoire centrale (disque
dur, disquette, clef USB ...).
L'accès aux différents éléments d'un fichier peut être soit séquentiel soit direct.

Déclaration d'un fichier


type
etudiant = record
matricule : string;
nom : string;
note : real;
end;
fichier = file of etudiant;
Remarque:

Un fichier une fois créé doit continuer à exister indépendamment du programme qui le
construit. Chaque fichier a un nom physique ou chemin d'accès qui se présente sous la
forme 'unité: nom_fichier.Extension' où unité peut être A: B: C: D:
nom_fichier est constitué de 1 à 8 caractères.

extention de 0 à 3 caractères.
Exemple:

'C:\Etude.txt'
Le nom du fichier est spécifié par l'instruction assign.
Exemple:

assign(fichier, 'C:\etude.txt')
Exemple:

var F: file of etudiant;


begin
assign(F, 'A:\etude.txt');

L'accès séquentiel à un fichier


Pour l'accès séquentiel on parcourt le fichier élément par élément pour obtenir l'élément à
traiter. Les primitives utilisées sont:

 rewrite(fichier) permet d'ouvrir le fichier en écriture. Si le fichier existe déjà son ancien contenu devient
inaccessible. Si le fichier n'existe pas encore, il sera tout simplement créé (pour l'instant il sera vide).
 reset(fichier) permet l'ouverture du fichier en lecture ou en lecture écriture. Dans ce cas le fichier doit
effectivement exister sinon il se produit une erreur d'exécution.
 write(fichier, val) cette instruction permet d'écrire le contenu de val dans le fichier. Seulement val doit être
du même type que les éléments du fichier.
 read(fichier, val) cette instruction permet d'introduire un élément du fichier dans val.
 eof(fichier) permet de détecter la fin du fichier. Cette fonction prend la valeur vraie si la fin du fichier a été
atteinte.
 close(fichier) permet de fermer le fichier à partir de là le fichier devient inaccessible.
Exemple:

program creation_fichier_etudiant;
type etudiant = record
matricule : string;
nom : string;
note : real;
end;
var fichir : file of etudiant;
personne : etudiant;

begin
assign(fichier, 'C:\etudiant.txt');
rewrite(fichier);
repeat
write('matricule: ')
readln(personne.matricule);
write('nom');
readln(personne.nom);
write('note: ');
readln(personne.note);
if length(personne.matricule) <> 0 then
write(fichier, personne);
until length(personne.matricule) = 0;
close(fichier);
end.
Exercice:

Ecrire un programme qui permet d'afficher la liste des informations des étudiants contenu
dans 'C:\etudiant.txt'.
Solution:

var F:file of etudiant


program affiche per: etudiant
begin
assign(F, 'C:\etudiant.txt');
reset(F);
read(F, per);
while not (eof(F)) do
begin
writeln(per.matricule);
writeln(per.nom);
writeln(per.note);
read(F, per);
end;
close(F);
end.
 

Accès direct
 

Il est possible d'accéder directement à un élément du fichier lorsqu'on connaît son


numéro.
La seule instruction nouvelle lors de l'accès direct est l'instruction seek(fichier, numéro)
qui place la tête de lecture à l'élément donc le numéro a été indiqué.
Par convention les éléments d'un fichier sont spécifiés à partir de 00 et non à partir de 1
Exemple: seek(F,2)

 filesize(fichier) renvoie le nombre d'élément.


 filesize(fichier)-1 pour trouver le dernier élément.
 seek(F, filesize(fichier)) pour placer le curseur à la fin du fichier.

Exemple:

procedure affiche_element(var F: fichier)


var val: etudiant; num: integer;
begin
assign(F,'C:\etudiant.txt');
reset(F);
writeln('Entrer un numéro: ');
repeat
write('Numéro = ');
readln(num);
until num <= filesize(F)
seek(F, num);
read(F, val);
writeln('Matricule: ',val.matricule);
writeln('nom: ', val.nom);
writeln('note: ',val.note);
close(F);
end;

Vous aimerez peut-être aussi