Formation Turbo Pascal
Formation Turbo Pascal de A a Z
...
CHAPITRE I : Entrées et sorties à l'écran
La commande write permet d'afficher du texte et de laisser le curseur à la fin du texte affiché. Cette commande permet d'afficher des chaînes de caractères d'excédant pas 255 signes ainsi que des valeurs de variables, de constantes, de types... Le texte doit être entre apostrophe. Si le texte à afficher contient une apostrophe, il faut alors la doubler. Les différents noms de variables doivent êtres séparés par des virgules.
Note : toute commande doit être suivie d'un point virgule.
Syntaxe :
Write ('Texte à afficher', variable1, variable2, 'texte2') ;
Write ('L"apostrophe se double.') ;
La commande WriteLn est semblable à la précédente à la différence près que le curseur est maintenant renvoyé à la ligne suivante.
Syntaxe :
WriteLn ('Texte avec renvoi à la ligne') ;
La commande read permet à l'utilisateur de rentrer une valeur qui sera utilisée par le programme. Cette commande ne provoque pas de retour Chariot, c'est-à-dire que le curseur ne passe pas à la ligne.
Syntaxe :
Read (variable) ;
La commande ReadLn permet à l'utilisateur de rentrer une valeur qui sera utilisée par le programme. Cette commande provoque le retour Chariot, c'est-à-dire que le curseur passe à la ligne suivante. Lorsqu'aucune variable n'est affectée à la commande, il suffit de presser sur <ENTREE>.
Syntaxe :
ReadLn (variable1, variable2) ;
ReadLn ;
Program exemple1;
Var nom : String ;
BEGIN
Write('Entrez votre nom : ') ;
ReadLn(nom) ;
WriteLn('Votre nom est ', nom) ;
ReadLn ;
END.
Ce programme exemple1 déclare tout d'abord la variable nommée nom comme étant une chaîne de caractère (String). Ensuite, dans le bloc programme principal, il est demandé à l'utilisateur d'affecter une valeur à la variable nom qui est initialisée automatiquement (valeur nulle) à chaque démarrage du programme. Ensuite, il y a affichage de la valeur de la variable et attente que la touche entrée soit validée (ReadLn).
L'équivalent de la commande ReadLn est ReadKey qui donne une valeur à une variable de type Char (caractère ASCII).
Syntaxe :
x := ReadKey ;
Il existe une équivalence à cette commande très utile pour sortir d'une boucle : KeyPressed.
Syntaxe :
Repeat
...
commandes
...
Until KeyPressed ;
Program exemple2 ;
Uses crt ;
Var i : integer ;
Const bornesup=10000 ;
BEGIN
Repeat
WriteLn(sqrt(i)) ;
Inc(i) ;
Until (i=bornesup) or KeyPressed ;
END.
Ce programme exemple2 répète une boucle jusqu'à qu'une valeur soit atteinte (bornesup) mais s'arrête si on appuie sur une touche. L'instruction Inc(a,n); incrémente la valeur n à la variable a (par défault n vaut 1), cette dernière étant de type integer.
CHAPITRE II : Opérateurs
Opérateurs mathématiques
Addition (et union1) +
Soustraction (et complément1) -
Division /
Multiplication (et intersection1) *
Egalité =
MOD : renvoie le reste de la division x MOD y
DIV : renvoie le quotient de la division x DIV y
Opérateurs prioritaires : *, /, DIV et MOD. Opérateurs secondaires : + et -. Vous pouvez utiliser des parentèses.
Opérateurs relationnels
Inférieur strict <
Inférieur ou égale (et inclu1) <=
Supérieur strict >
Supérieur ou égale (et contenant1) >=
Différent <>
Opérateur ultra-prioritaire : NOT. Opérateur semi-prioritaire : AND. Opérateur non
prioritaires : OR et XOR.
Opérateurs logiques :
AND : le "et" logique des maths (voir chapitre 15 sur les booléens et tables de vérité) OR : le "ou"
XOR : le "ou" exclusif
NOT : le "non"
Priorité des opérateurs
Niveau 1 : NOT.
Niveau 2 : *, /, MOD, DIV, AND. Niveau 3 : +, -, OR, XOR.
Niveau 4 : =, <, >, <=, >=, <>.
1: les opérateurs union, complément, intersection, inclu et contenant s'appliquent aux ensembles (voir Chap XXV).
CHAPITRE III : Variables, formats et maths
- Déclaration
- Prise de valeurs
- Fonctions
- Emplois
- Opérations
- Format
- Déclaration
Toutes les variables doivent êtres préalablement déclarées avant d'être utilisées dans le programme, c'est-à-dire qu'on leur affecte un type (voir types de variables). On peut les déclarer de divers manières :
Au tout début du programme avec la syntaxe VAR nom de la variable : type ; elles seront alors valables pour le programme dans son intégralité (sous-programmes, fonctions, procédures...).
Au début d'une procédure avec la syntaxe précédente. Elles ne seront valables que dans la procédure.
Après la déclaration des procédures, toujours avec la même syntaxe, elles ne pourront alors pas êtres utilisée par les procédures qui devront donc être paramétrées (voir procédures paramétrées).
- Prise de valeurs
Les variables sont faites pour varier, il faut donc pouvoir leur donner différentes valeurs au moyen du commutateur suivant := (deux points et signe égale) ou de certaines fonction. Il faut bien sûr que la valeur donnée soit compatible avec le type utilisé. Ainsi, on ne peut donner la valeur 'bonjour' à un nombre entier (integer).
Syntaxes :
Y := 1998 ;
On donne ainsi la valeur 1998 à la variable Y (déclarée préalablement en INTEGER). LETTRE := 'a' ;
On affecte la valeur a à la variable LETTRE (déclarée préalablement en CHAR). TEST := true ;
On donne la valeur true (vrai) à la variable TEST (déclarée préalablement en BOOLEAN). NOMBRE := Y + 103 ;
Il est ainsi possible d'utiliser les valeurs d'autres variables, du moment qu'elles sont de même type, sinon, il faut faire des conversions au préalable. DELTA := sqr(b) - 4*(a*c) ;
On peut donc également utiliser une expression littérale mathématique dans l'affectation de variables. Mais attention à la priorité des opérateurs (voir opérateurs).
PHRASE := 'Bonjour' + chr(32) + NOM ;
On peut aussi ajouter des variables String (voir Chapitre 13 pour les chaînes de caractères).
- Fonctions
Fonction mathématiques Pascal de base
Syntaxe Fonction
Sin(a) sinus
Cos(a) cosinus
ArcTan(a) arctangeante
Abs(a) valeur absolue
Sqr(a) carré
Sqrt(a) racine carré
Exp(a) exponentielle
Ln(a) logarithme népérien
L'argument des fonctions trigonométriques doit être exprimé en radian (Real), à vous donc de faire une convertion si nécessaire. De plus, on peut voir que les fonctions tangente, factorielle n'existent pas, il faudra donc créer de toute pièce les fonctions désirées (voir fonctions).
- Emplois
Les variables peuvent êtres utilisées dans de nombreux emplois :
Pour des comparaisons dans une structure conditionnelle (voir chapitre 4 sur les conditions).
Pour l'affichage de résultats (voir chapitre 1 sur l'affichage).
Pour le dialogue avec l'utilisateur du programme (voir chapitre 1 sur les entrées au clavier).
Pour excécuter des boucles (voir chapitre 6)...
- Opérations
Syntaxe Utilisation Type des variables Description
Inc(a); Procédure intervalle ou énuméré Le nombre a est incrémenté de 1
Inc(a,n); Procédure intervalle ou énuméré Le nombre a est incrémenté de n
Dec(a); Procédure intervalle ou énuméré Le nombre a est décrémenté de 1
Dec(a,n); Procédure intervalle ou énuméré Le nombre a est décrémenté de n
Trunc(a) Fonction tout scalaire Prise de la partie entière du nombre a sans arrondis
Int(a) Fonction a:Real
Int(a):Longint Prise de la partie entière du nombre a sans arrondis
Frac(a) Fonction Real Prise de la partie fractionnaire du nombre a
Round(a) Fonction a:Real
Round(a):Longin Prise de la partie entière du nombre a avec arrondi à l'unité la plus proche
tPred(x) Fonction intervalle ou énuméré Renvoit le prédécesseur de la variable x dans un ensembre ordonnée
Succ(x) Fonction intervalle ou énuméré Renvoit le successeur de la variable x dans un ensembre ordonnée
Hight(x) Fonction tous Renvoit la plus grande valeur possible que peut prendre de la variable x
Low(x) Fonction tous Renvoit la plus petite valeur possible que peut prendre de la variable x
Odd (a) Fonction a : Longint
Odd(a):Boolean Renvoit true si le nombre a est impair et false si a est pair
SizeOf(x) Fonction x:tous
SizeOf(x):Integ er Renvoit renvoit le nombre d'octets
occupés par la variable x
- Format
Sachez encore que le format (le nombre de signes) d'une variable de type real peut être modifié :
Lors de son affichage : WriteLn ( nombre : 5 ) ; pour mettre 5 espaces devant le nombre.
Lors de son affichage (bis) : WriteLn ( nombre : 0 : 5 ) ; pour ne mettre aucun espace avant mais pour n'afficher que 5 signes (un réel en possède bien plus).
Pour pouvez appliquer ce format pour tous les autres types de variable de manière générale si vous ne stipuler que le nombre d'espace(s) à afficher devant votre texte ou valeur.
Exemple : WriteLn ( 'Coucou' : 20 ) ;
Ici, la chaîne de caractères sera affichée après 20 espaces.
CHAPITRE IV : Différents types de variables
On peut donner n'importe quel nom aux variables à condition qu'il ne fasse pas plus de 127 caractères et qu'il ne soit pas utilisé par une fonction, procédure, unité ou commande déjà existante.
Les identificateurs ne doivent pas contenir de caractères accentués, ni d'espace. Ils doivent exclusivement être composés des 26 lettres de l'alphabet, des 10 chiffres et du caractère de soulignement. De plus, Turbo Pascal ne différencie aucunement les majuscules des minuscules et un chiffre ne peut pas être placé en début de nom de variable.
Petite liste-exemple très loin d'être exhaustive :
Désignation Description Bornes Place en mémoire
REAL nombres réels 2.9E-039 et 1.7E+038 6 octets
SINGLE(*) réel 1.5E-045 et 3.4E+038 4 octets
DOUBLE(*) réel 5.0E-324 et 1.7E+308 8 octets
EXTENDED(*) réel 1.9E-4951 et 1.1E+4932 10 octets
COMP(*) réel -2E+063 +1 et 2E+063 +1 8 octets
INTEGER nombres entier (sans virgule) -32768 et 32767 2 octets
LONGINT entier -2147483648 et
2147483647 4 octets
SHORTINT entier -128 et 127 1 octet
WORD entier 0 et 65535 2 octets
BYTE entier 0 et 255 1 octet
LONG entier (-2)^31 et (2^31)-1 4 octets
BOOLEAN variable booléenne TRUE ou FALSE 1 octet
ARRAY [1..10] OF xxx tableau de 10 colones fait d'éléments de l'ensemble défini xxx (CHAR, INTEGER...)
ARRAY [1..10, 1..50, 1..13] OF xxx tableau en 3 dimensions fait d'éléments de l'ensemble défini xxx (CHAR, INTEGER...)
STRING chaîne de caractères 256 octets
STRING [y] chaîne de caractère ne devant pas excéder y caractères y+1 octets
TEXT fichier texte
FILE fichier
FILE OF xxx fichier contenant des données de type xxx (REAL, BYTE...)
CHAR nombre correspondant à un caractère ASCII codé 0 et 255 1 octet
POINTEUR adresse mémoire 4 octet
DATETIME format de date
PATHSTR chaîne de caractère (nom
complet de fichier)
DIRSTR chaîne de caractère (chemin de fichier)
NAMESTR chaîne de caractère (nom de fichier)
EXTSTR chaîne de caractère (extention de fichier)
(*) : nécessitent un co-processeur mathématique.
CHAPITRE V : Structures alternatives
- If ... Then ... Else ;
- Case ... Of ... End ;
- If ... Then ... Else
Cette commande est similaire au basic, elle se traduit par : SI ... ALORS ... SINON ...
Program exemple3a ;
Var chiffre:integer ;
BEGIN
Write('Entrez un entier pas trop grand : ') ;
Readln(chiffre) ;
If chiffre < 100 then writeln(chiffre, ' est inférieur à cent.') else
writeln(chiffre, ' est supérieur ou égale à cent.') ;
END.
Ce programme exemple3a compare un chiffre entré par l'utilisateur au scalaire 100. Si le chiffre est inférieur à 100, alors il affiche cette information à l'écran, sinon il affiche que le chiffre entré est supérieur ou égale à 100.
Program exemple3b ;
Var chiffre:integer ;
BEGIN
Write('Entrez un entier pas trop grand : ') ;
Readln(chiffre) ;
If chiffre < 100 then
begin
writeln(chiffre, ' est inférieur à cent.') ;
end
else
begin
writeln(chiffre, ' est supérieur ou égale à cent.') ;
end ;
END.
Ce programme exemple3b fait strictement la même chose que le 3a mais sa structure permet d'insérer plusieurs autres commandes dans les sous-blocs THEN et ELSE. Notez que le END terminant le THEN ne possède pas de point virgule car s'il en possédait un, alors le ELSE n'aurait rien à faire ici et le bloc condition se stopperait avant le ELSE.
Il est également possible d'insérer d'autres bloc IF dans un ELSE, comme l'illustre l'exemple3c qui suit :
Program exemple3c ; Var i : integer ; BEGIN
Randomize ;
i := random(100) ;
if i < 50 then writeln ( i, ' est inférieur à 50.')
else if i < 73 then writeln ( i, ' est inférieur à 73.')
else writeln ( i, ' est supérieur ou égale à 73.')
END.
- Case ... Of ... End
Cette instruction compare la valeur d'une variable de type entié ou caractère (et de manière générale de type intervalle, voir Chap Type) à tout un tas d'autres valeurs constantes.
Note : attention car Case Of ne permet de comparer une variable qu'avec des constantes.
Program exemple4 ;
Var age:integer ;
BEGIN
Write('Entrez votre âge : ') ;
Readln(age) ;
Case age of
18 : writeln('La majorité, pile-poil !') ;
0..17 : writeln('Venez à moi, les petits enfants...') ;
60..99 : writeln('Les infirmières vous laisse jouer sur l"ordinateur à
votre âge ?!!!')
Else writeln('Vous êtes d"un autre âge...') ;
End ;
END.
Ce programme exemple4a vérifie certaines conditions quant à la valeur de la variable age dont l'a affecté l'utilisateur. Et là, attention : le point-virgule avant le Else est facultatif. Mais pour plus sécurité afin de ne pas faire d'erreur avec le bloc If, choisissez systématiquement d'ommettre le point-virgule avant un Else.
Note : On peut effectuer un test de plusieurs valeurs en une seule ligne par séparartion avec une virgule si on souhaite un même traitement pour plusieurs valeurs différentes. Ainsi la ligne :
0..17 : writeln('Venez à moi, les petits enfants...') ;
peut devenir :
0..10, 11..17 : writeln('Venez à moi, les petits enfants...') ;
ou encore :
0..9, 10, 11..17 : writeln('Venez à moi, les petits enfants...') ;
ou même :
0..17, 5..10 : writeln('Venez à moi, les petits enfants...') ;
{ cette dernière ligne est stupide mais correcte ! }
CHAPITRE VI : Structures répétitives
- For ... : = ... To ... Do ...
- For ... : = ... DownTo ... Do ...
- Repeat ... Until ...
- While ... Do ...
- Arrêts de boucle.
- For ... : = ... To ... Do ...
Cette instruction permet d'incrémenter une variable à partir d'une valeur inférieur jusqu'à une valeur supérieur et d'exécuter une ou des instructions entre chaque incrémentation. Les valeurs extrémum doivent être des entiers (integer) ou des caractères de la table ASCII (char). De manière plus générale, les bornes doivent être de type intervalle (voir chap Type) c'est-à-dire qu'ils doivent êtres de type entier ou compatibles avec un type entier. La boucle n'exécute les instructions de son bloc interne que si la valeur inférieur est effectivement inférieur ou égale à celle de la borne supérieur. Le pas de variation est l'unité et ne peut pas être changé.
Syntaxe :
For variable := borne inférieur To borne supérieur Do instruction ;
Autre Syntaxe :
For variable := borne inférieur To borne supérieur Do
Begin
...
commandes
...
End ;
Program exemple5 ;
Var i : integer ;
BEGIN
For i := 10 To 53 Do writeln ('Valeur de i : ', i ) ;
END.
- For ... : = ... DownTo ... Do ...
Cette instruction permet de décrémenter une variable à partir d'une valeur supérieur jusqu'à une valeur inférieur et d'exécuter une ou des instructions entre chaque décrémentation. S'appliquent ici les mêmes remarques que précédement.
Syntaxe :
For variable := borne supérieur DownTo borne inférieur Do instruction ;
Autre Syntaxe :
For variable := borne supérieur DownTo borne inférieur Do
Begin
...
commandes
...
End ;
Program exemple6 ;
Var i : integer ;
BEGIN
For i := 100 DownTo 0 Do
Begin
WriteLn ('Valeur de i : ', i ) ;
End ;
END.
- Repeat ... Until ...
Cette boucle effectue les instructions placées entre deux bornes (repeat et until) et évalue à chaque répétition une condition de type bouléenne avant de continuer la boucle pour décider l'arrêt ou la continuité de la répétition. Il y a donc au moins une fois exécution des instructions. Il est nécessaire qu'au moins une variable intervenant lors de l'évaluation de fin de boucle soit sujette à modification à l'intérieur de la structure exécutive interne à la boucle.
Syntaxe :
Repeat
...
commandes
...
Until variable condition valeur ;
Program exemple7 ;
Uses crt ;
Var i : integer ;
BEGIN
Repeat
Inc ( i , 1 ) ;
Writeln ('Boucle itérée ', i, ' fois.') ;
Until i > 20 ;
END.
Ce programme exemple7 permet de répéter l'incrémentation de la variable i jusqu'à que i soit supérieure à 20.
Note : la commande Inc permet d'incrémenter une variable d'une certaine valeur. La commande Dec permet au contraire de décrémenter une variable d'une certaine valeur. Ces commandes permettent d'éviter la syntaxe : variable := variable + 1 et variable := variable - 1.
Syntaxe :
Inc ( variable , nombre ) ; Dec ( variable , nombre ) ;
- While ... Do ...
Ce type de boucle, contrairement à la précédente, évalue une condition avant d'exécuter des instructions (et nom pas l'inverse), c'est-à-dire qu'on peut ne pas entrer dans la structure de répétition si les conditions ne sont pas favorables. De plus, au moins une variable de l'expression d'évaluation doit être sujette à modification au sein de la structure de répétition pour qu'on puisse en sortir.
Syntaxe :
While variable condition valeur Do instruction ;
Autre Syntaxe :
While variable condition valeur Do
Begin
...
commandes
...
End ;
Program exemple8 ;
Var code : boolean ;
essai : string ;
Const levraicode = 'password' ;
BEGIN
code:=false ; { facultatif, la valeur false est donnée par défault }
While code = false Do
Begin
Write ('Entrez le code secret : ') ;
Readln (essai) ;
If essai = levraicode then code:=true ;
End ;
END.
- Arrêts de boucle.
Il est possible de terminer une boucle For, While ou Repeat en cours grâce à la commande Break lorsque celle-ci est placée au sein de la boucle en question.
Pour reprendre une boucle stoppée par Break, il faut utiliser la commande Continue.
Program arrets1 ;
Var i, x : Integer ;
BEGIN
x := 0 ;
Repeat
Inc(i) ;
Break ;
x := 50 ;
Continue ;
Until i>10 ; WriteLn(x) ;
END.
Ce programme arrets1 stoppe systématiquement une boucle Repeat avant que la variable x puisse être incrémenté de 50 et la reprend après la ligne d'incrémentation. Ce qui a pour résultats que la variable x soit nulle à la fin du programme.
Program arrets2 ;
Var i, x : Integer ; BEGIN
x := 0 ;
For i := 1 to 10 Do Begin
Break ; x := 50 ;
Continue ; End ;
WriteLn(x) ;
END.
Ce programme arrets2 fait la même chose que le programme précédent mais dans une boucle For.
Program arrets3 ;
Var i, x : Integer ;
BEGIN
x := 0 ;
While i<10 Do
Begin
Break ;
x := 50 ;
Continue ;
End ;
WriteLn(x) ;
END.
Ce programme arrets3 fait la même chose que les programmes précédents mais dans une boucle While.
Et pour quitter un bloc sous-programme (structure Begin ... End ;) ou même le programme principal (structure Begin ... End.) , utilisez la commande Exit.
Program arrets4 ;
Var i : Integer ;
BEGIN
While i <> 13 Do
Begin
Write ('Entrez un nombre : ') ;
Readln (i) ;
Writeln (i) ;
If i = 0 Then Exit ; End ;
Writeln ('Boucle terminée.') ;
END.
CHAPITRE VII : Procédures
Les procédures et fonctions sont des sortes de sous-programmes écrits avant le programme principal mais appelés depuis ce programme principal, d'une autre procédure ou même d'une autre fonction. Le nom d'une procédure ou d'une fonction (ou comme celui d'un tableau, d'une variable ou d'une constante) de doit pas excéder 127 caractères et ne pas contenir d'accent. Ce nom doit, en outre, être différent de celui d'une instruction en Pascal. L'appel d'une procédure peut dépendre d'une structure de boucle, de condition, etc.
- Procédure simple
- Variables locales et sous-procédures
- Procédure paramétrée
- Syntaxe Var
- Procédure simple
Une procédure peut voir ses variables définies par le programme principal, c'est-à-dire que ces variables sont valables pour tout le programme et accessible partout dans le programme principal mais aussi dans les procédures et fonctions qui auront été déclarées après. La déclaration des variables se fait alors avant la déclaration de la procédure pour qu'elle puisse les utiliser. Car une procédure déclarée avant les variables ne peut pas connaître leur existence et ne peut donc pas les utiliser.
Syntaxe :
Program nom de programme ; Var variable : type ;
Procedure nom de procédure ; Begin
...
commandes
...
End ;
BEGIN
nom de procédure ; END.
Program exemple9a ; Uses crt ;
Var a, b, c : real ; Procedure maths ; Begin
a := a + 10 ;
b := sqrt(a) ;
c := sin(b) ;
End ;
BEGIN
Clrscr ;
Write('Entrez un nombre :') ;
Readln(a) ;
Repeat
maths ;
Writeln (c) ;
Until keypressed ; END.
Ce programme exemple9a appelle une procédure appelée maths qui effectue des calculs successifs. Cette procédure est appelée depuis une boucle qui ne se stoppe que lorsqu'une touche du clavier est pressée (instruction keypressed). Durant cette procédure, on additionne 10 à la valeur de a entrée par l'utilisateur, puis on effectue le carré (sqrt) du nombre ainsi obtenu, et enfin, on cherche le sinus (sin) de ce dernier nombre.
- Variables locales et sous-procédures
Une procédure peut avoir ses propres variables locales qui seront réinitialisées à chaque appel. Ces variables n'existent alors que dans la procédure. Ainsi, une procédure peut utiliser les variables globales du programme (déclarées en tout début) mais aussi ses propres variables locales qui lui sont réservées. Une procédure ne peut pas appeler une variable locale appartenant à une autre procédure. Les variables locales doivent porter des noms différents de celles globales si ces dernières ont été déclarée avant la procédure. Enfin, on peut utiliser dans une procédure, un nom pour une variable locale déjà utilisé pour une autre variable locale dans une autre procédure.
Une procédure, étant un sous-programme complet, peut contenir ses propres procédures et fonctions qui n'existent alors que lorsque la procédure principale est en cours. Un sous-procédure ne peut appeler d'autres procédures ou fonctions que si ces dernières font parti du programme principal ou de la procédure qui contient la sous-procédure.
Syntaxe :
Procedure nom de procédure ;
Var variable : type ;
Procedure nom de sous-procédure ;
Var variable : type ;
Begin
...
End ;
Begin
...
commandes
...
End ;
- Procédure paramétrée
On peut aussi créer des procédures paramétrées (dont les variables n'existent que dans la procédure). Ces procédures là ont l'intérêt de pouvoir, contrairement aux procédures simples, être déclarée avant les variables globales du programme principal ; elles n'utiliseront que les variables passées en paramètres ! Le programme principal (ou une autre procédure qui aurait été déclarée après) affecte alors des valeurs de variables à la procédure en passant des variables en paramètres. Et ces valeurs s'incorporent dans les variables propres à la procédure (dont les identificateurs peuvent ou non êtres identiques, ça n'a aucune espèce d'importance). La déclaration des variables se fait alors en même temps que la déclaration de la procédure, ces variables sont des paramètres formels car existant uniquement dans la procédure. Lorsque que le programme appelle la procédure et lui envoie des valeurs de type simple (car celles de type complexe ne sont pas acceptées, voir chapitre 20 sur les types), celles-ci sont appelées paramètres réels car les variables sont définies dans le programme principal et ne sont pas valables dans la procédure.
A noter qu'on peut passer en paramètre directement des valeurs (nombre, chaînes de caractères...) aussi bien que des variables.
Syntaxe :
Program nom de programme ;
Procedure nom de procédure( noms de variables : types ) ;
Begin
...
commandes
...
End ;
BEGIN
nom de procédure ( noms d'autres variables ou leurs valeurs ) ;
END.
Note : on peut passer en paramètre à une procédure des types simples et structurés. Attention néanmoins à déclarer des types spécifiques de tableau à l'aide de la syntaxe Type (voir Chapitre 20 sur les "Types simples et structurés") car le passage d'un tableau en tant que type Array à une procédure est impossible.
Program exemple9b ;
Uses Crt ;
Procedure maths ( param : Real ) ;
Begin
WriteLn('Procédure de calcul. Veuillez patienter.') ;
param := Sin(Sqrt(param+10)) ;
WriteLn(param) ;
End ;
Var nombre : Real ;
BEGIN
ClrScr ;
Write('Entrez un nombre :') ;
ReadLn(nombre) ;
maths (nombre) ;
ReadLn ;
END.
Ce programme exemple9b appelle une procédure paramétrée appelée maths qui effectue les mêmes calculs que le programme exemple9a. Mais ici, la variable est déclarée après la procédure paramétrée. Donc, la procédure ne connaît pas l'existdnce de la variable nombre, ainsi, pour qu'elle puisse l'utiliser, il faut le lui passer en paramètre !
- Syntaxe Var (procédures et fonctions)
Il est quelquefois nécessaire d'appeler une procédure paramétrée sans pour autant avoir de valeur à lui affecter mais on souhaiterait que ce soit elle qui nous renvoie des valeurs (exemple typique d'une procédure de saisie de valeurs par l'utilisateur) ou alors on désire que la procédure puisse modifier la valeur de la variable passée en paramètre. Les syntaxes précédentes ne conviennent pas à ce cas spécial. Lors de la déclaration de variable au sein de la procédure paramétrée, la syntaxe Var (placée devant l'identificateur de la variable ) permet de déclarer des paramètres formels dont la valeur à l'intérieur de la procédure ira remplacer la valeur, dans le programme principal, de la variable passée en paramètre. Et lorsque Var n'est pas là, les paramètres formels doivent impérativement avoir une valeur lors de l'appel de la procédure.
Pour expliquer autrement, si Var n'est pas là, la variable qu'on envoie en paramètre à la procédure doit absolument déjà avoir une valeur (valeur nulle acceptée). De plus, sans Var, la variable (à l'intérieur de la procédure) qui contient la valeur de la variable passée en paramètre, même si elle change de valeur n'aura aucun effet sur la valeur de la variable (du programme principal) passée en paramètre. C'est à dire que la variable de la procédure n'existe qu'à l'intérieur de cette dernière et ne peut absolument pas affecter en quoi que ce soit la valeur initiale qui fut envoyée à la procédure : cette valeur initiale reste la même avant et après l'appel de la procédure. Car en effet, la variable de la procédure est dynamique : elle est créée lorsque la procédure est appelée et elle est détruite lorsque la procédure est finie, et ce, sans retour d'information vers le programme principal. La procédure paramétrée sans Var évolue sans aucune interaction avec le programme principal (même si elle est capable d'appeler elle-même d'autres procédures et fonctions).
Par contre, si Var est là, la valeur de la variable globale passée en paramètre à la procédure va pouvoir changer (elle pourra donc ne rien contenir à l'origine). Si au cours de la procédure la valeur est changée (lors d'un calcul, d'une saisie de l'utilisateur...), alors la nouvelle valeur de la variable dans la procédure, une fois la procédure terminée, ira se placer dans la variable globale (du programme principal) qui avait été passée en paramètre à la procédure. Donc, si on veut passer une variable en paramètre dont la valeur dans le programme principal ne doit pas être modifiée (même si elle change dans la procédure), on n'utilise pas le Var. Et dans le cas contraire, si on veut de la valeur de la variable globale placée en paramètre change grâce à la procédure (saisie, calcul...), on colle un Var.
Program Exemple9c ;
Uses Crt ;
Procedure Saisie ( var nom : String ) ;
Begin
Write('Entrez votre nom : ') ;
ReadLn(nom) ;
End ;
Procedure Affichage ( info : String ) ;
Begin
WriteLn('Voici votre nom : ', info) ;
End ;
Var chaine : String ;
BEGIN
ClrScr ;
Saisie(chaine) ;
Affichage(chaine) ;
END.
Ce programme exemple9c illustre l'utilisation de la syntaxe Var. En effet, le programme principal appelle pour commencer une procédure paramétrée Saisie et lui affecte la valeur de la variable chaine (c'est-à-dire rien du tout puisque qu'avant on n'a rien mis dedans, même pas une chaîne vide). Au sein de la procédure paramétrée, cette variable porte un autre nom : nom, et comme au début du programme cette variable n'a aucune valeur, on offre à la procédure la possibilité de modifier le contenu de la variable qu'on lui envoie, c'est-à-dire ici d'y mettre le nom de l'utilisateur. Pour cela, on utilise la syntaxe Var. Lorsque cette procédure Saisie est terminée, la variable chaine du programme principal prend la valeur de la variable nom de la procédure. Ensuite, on envoie à la procédure Affichage la valeur de la variable chaine (c'est-à-dire ce que contenait la variable nom, variable qui fut détruite lorsque la procédure Saisie se termina). Comme cette dernière procédure n'a pas pour objet de modifier la valeur de cette variable, on n'utilise pas le mot clé Var, ainsi, la valeur de la variable chaine ne pourra pas être modifiée par la procédure. Par contre, même sans Var, la valeur de la variable info pourrait varier au sein de la procédure si on le voulait mais cela n'aurait aucune influence sur la variable globale chaine. Comme cette variable info n'est définie que dans la procédure, elle n'existera plus quand la procédure sera terminée.
Il faut savoir qu'une procédure paramétrée peut accepter, si on le désire, plusieurs variables d'un même type et aussi plusieurs variables de types différents. Ainsi, certaines pourront êtres associées au Var, et d'autres pas. Si l'on déclare, dans une procédure paramétrée, plusieurs variables de même type dont les valeurs de certaines devront remplacer celles initiales, mais d'autres non ; il faudra déclarer séparément (séparation par une virgule ;) les variables déclarée avec Var et les autres sans Var. Si on déclare plusieurs variables de types différents et qu'on veut que leurs changements de valeur affecte les variables globales, alors on devra placer devant chaque déclaration de types différents un Var.
Syntaxes :
Procedure identifiant(Var var1, var2 : type1 ; var3 : type1) ;
Begin
...
End ;
Procedure identifiant(Var var1 : type1 ; Var var2 : type2) ;
Begin
...
End ;
CHAPITRE VIII : Fonctions
Quant aux fonctions, elle sont appelées à partir du programme principal, d'une procédure ou d'une autre fonction. Le programme affecte des valeurs à leur variables (comme pour les procédures paramétrées, il faudra faire attention à l'ordre d'affectation des variables). Ces fonctions, après lancement, sont affectées elles-mêmes d'une valeur intrinsèque issue de leur fonctionnement interne. Il faut déclarer une fonction en lui donnant tout d'abord un identifiant (c'est-à-dire un nom d'appel), en déclarant les variables locales dont elle aura besoin et enfin, il faudra préciser le type correspondant à la valeur que prendra en elle-même la fonction (string, real, etc.). Attention, on ne peut pas affecter un type complexe (array, record) à une fonction : seuls les types simples sont acceptés (voir chapitre 20 sur les types simples et complexes). De plus, comme le montre les syntaxes suivantes, on peut fabriquer une fonction sans paramètre (ex: random). Il ne faut surtout pas oublier, en fin (ou cours) de fonction, de donner une valeur à la fonction c'est-à-dire d'affecter le contenu d'une variable ou le résultat d'une opération (ou autre...) à l'identifiant de la fonction (son nom) comme le montrent les syntaxes suivantes.
Syntaxes :
Function nom de fonction (variable : type ) : type ;
Var déclaration de variables locales ;
Begin
...
commandes
...
nom de fonction := une valeur ; End ;
Function nom de fonction : type ; Var déclaration de variables locales ; Begin
...
commandes
...
nom de fonction := une valeur ; End ; >
Program exemple10 ;
Uses crt ;
Function exposant ( i , j : integer ) : integer ;
Var i2 , a : integer ;
Begin
i2 := 1 ;
For a := 1 To j Do i2 := i2 * i ;
exposant := i2 ;
End ;
Var resultat, x, n : integer ;
BEGIN
Write ('Entrez un nombre : ') ; Readln (x) ;
Write('Entrez un exposant : ') ; Readln (n) ;
resultat := exposant ( x , n ) ; Writeln ( resultat ) ;
Readln ;
END.
