Support de cours général pour apprendre le langage Delphi et Pascal


Télécharger Support de cours général pour apprendre le langage Delphi et Pascal

★★★★★★★★★★1 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Télécharger aussi :


Support de cours général pour apprendre le langage Delphi et Pascal

...

Généralités

Architecture standard d'un listing en pascal

{ les instructions facultatives pour compilation doivent êtres entre accolades }

Program nom de programme ; Uses unités utilisées ;

Const déclaration de constantes ; Type déclaration de types ; Function déclaration de fonction ;

Procedure déclaration de procédure paramétrée ; Var déclaration de variables ;

Procedure déclaration de procédure simple ; BEGIN { programme principal }

...

Commandes

...

END.

Grammaire du Pascal

Un nom de programme respecte les règles liées aux identificateurs (cf plus bas) et ne peut pas contenir le caractère point "."

Un programme principal débute toujours par BEGIN et se termine par END. (avec un point). Alors qu'un sous-programme (ou fonction, procédure, bloc conditionnel...) commence lui aussi par Begin mais se termine par End ; (sans point mais avec un point-virgule).

Chaque commande doit se terminer avec un point-virgule. Il n'y a pas d'exception à la règle hormis Begin et l'instruction précédent End ou Else.

Il est toléré de mettre plusieurs instructions les unes à la suite des autres sur une même ligne du fichier mais il est recommandé de n'en écrire qu'une par ligne : c'est plus clair et en cas de bogue, on s'y retrouve plus aisément. De plus, s'il vous arrive d'écrire une ligne trop longue, le compilateur vous le signifiera en l'erreur Error 11: Line too long. Il vous faudra alors effectuer des retours à la ligne comme le montre l'exemple             suivant : WriteLn('Fichier: ', file,

'               Date de création:', datecrea, ' Utilisateur courant:', nom,

'               Numéro de code:', Round(ArcTan(x_enter)*y_old):0:10) ; Les noms de constantes, variables, procédures, fonctions, tableaux, etc. (appellés identificateurs) doivent êtres des noms simples, par exemple, n'appelez pas une variable comme ça : x4v_t3la78yugh456b2dfgt mais plutôt comme cela : discriminant (pour un programme sur les éq du 2nd degré) ou i (pour une variable de boucle).

Les identificateurs doivent impérativement être différents de ceux d'unité utilisées, de mots réservés du langage Pascal et ne doivent pas exéder 127 signes (1 lettre au minimum). Ils ne doivent être composés que de lettres, de chiffres et du caractère de soulignement (Shift+8).

Les identificateurs ne doivent pas contenir de caractères accentués, ni d'espace, ni de point et ni les caractères suivants : @, $, &, #, +, -, *, /. Mais le caractère de soulignement est autorisé. De plus, Turbo Pascal ne différencie aucunement les majuscules des minuscules. Les chiffres sont acceptés ormis en première place.

N'hésitez pas à insérer des commentaires dans votre code, cela vous permettra de comprendre vos programme un an après les avoir écrit, et ainsi d'autres personnes n'auront aucun mal à réutiliser vos procédures, fonctions... Procédez ainsi :

{     ici     votre     commentaire    entre    accolades            } (*   ici      vos      commentaires      entre      parenthèses      et      étoiles      *) Vos commentaires peuvent tenir sur une seule ligne comme sur plusieurs. Vous pouvez aussi mettre en commentaire une partie de votre programme.

Un identificateur ne peut être égale à un mot réservé du langage pascal !

Mots réservés du langage Pascal

AND, ARRAY, ASM, BEGIN, CASE, CONST, CONSTRUCTOR, DESTRUCTOR, DIV, DO, DOWNTO, ELSE, END, EXPORTS, FILE, FOR, FUNCTION, GOTO, IF, IMPLEMENTATION, IN, INHERITED, INLINE, INTERFACE, LABEL, LIBRARY, MOD, NIL, NOT, OBJECT, OF, OR, PACKED, PROCEDURE, PROGRAM, RECORD, REPEAT, SET, SHL, SHR, STRING, THEN, TO, TYPE, UNIT, UNTIL, USES, VAR, WHILE, WITH, XOR.

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

.

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

  1. Déclaration
  2. Prise de valeurs
  3. Fonctions
  4. Emplois
  5. Opérations
  6. Format
  7. 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).

  1. 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).

...

CHAPITRE V : Structures alternatives

  1. If ... Then ... Else ;
  2. Case ... Of ... End ;
  3. 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.

  1. 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

  1. For ... : = ... To ... Do ...
  2. For ... : = ... DownTo ... Do ...
  3. Repeat ... Until ...
  4. While ... Do ...
  5. Arrêts de boucle.
  6. 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.

  1. 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.

  1. 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 ) ;

  1. 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.

  1. 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 ;

END.

 Until i>10 ; WriteLn(x) ;

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

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) ;

END.

Writeln (i) ;

If i = 0 Then Exit ; End ;

Writeln ('Boucle terminée.') ;

 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.



  1. Procédure simple
  2. Variables locales et sous-procédures
  3. Procédure paramétrée
  4. Syntaxe Var
  5. 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.

  1. 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 ;

  1. 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 !

  1. 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 ;



2147