PASCAL

Les bases du langage Pascal

De la structure du langage et des principaux mots-clés

Tout d'abord, nous sommes d'accord : notre but est d'écrire un programme; quand notre programme sera suffisamment élaboré, on pourra appeler ça une application (ça fait pro). Tous nos programmes seront constitués de la même manière, dont voici un exemple :

Program MonProg;
begin
end. 

Il faut savoir que le code source d'un programme Pascal, c'est un fichier texte, que l'on pourrait tout à fait écrire avec le bloc-notes de Windows. Autrement dit, il s'agit d'un texte sans aucune mise en forme (pas de gras, italique...). Donc pour s'y retrouver un peu, on met des majuscules, mais c'est uniquement pour faciliter la lecture. Évidemment, ce programme ne fait rien, mais il se compilera et s'exécutera quand même. Program, begin et end sont des mots-clés. Il existe comme cela de nombreux mot-clés, qui ne peuvent être utilisés à d'autre fin que celle définie par le compilateur. MonProg est le nom que j'ai donné au programme (noter le point-virgule après MonProg, et le point après end). Si on complique, on pourrait avoir :

Program MonProg;
var 
  i : integer;
begin
  i:=1;
end. 

Dans cet exemple, on a commencé à ajouter des traitements à faire, sous forme d'instructions. On utilise une variable, qui s'appelle i, et dans laquelle on met la valeur 1. Cela se traduit par l'instruction "i:=1". Cette variable doit obligatoirement être déclarée en début de programme, grâce à la clause VAR. En fait dans cette clause, on stocke toutes les déclarations de toutes les variables. Par exemple :

Program MonProg;
var 
  i : integer;
  j : string;
begin
  i:=1;
  j:='Bonjour à tous';
end. 

Notez les points-virgules en fin de chaque instruction. Pour rendre le texte plus lisible, on indente le texte, de manière à ce que chaque bloc soit décalé vers la droite. Deux espaces suffisent pour dégager ce que contient la clause VAR et ce qu'il y a entre le begin et le end. Cette présentation est extrêmement importante : utilisez-la au fur et à mesure que vous tapez le texte, et non après avoir tout tapé.

Texte non indenté, à NE PAS FAIRE :

Program MonProg;
var 
i : integer;
j : string;
begin
i:=1;
j:='Bonjour à tous';
end. 

Allez, puisqu'on est bien avancé, je vous présente d'un coup d'un seul la structure complète d'un programme :

Program <nom du prog>;

uses MonUnit1, MonUnit2, ...;

const
  maconstante1 = <valeur>;
  ...
type
  montype1 : <type de donnée>;
  montype2 : <type de donnée>;
  ...
var
  mavar1 : <type de donnée>;
  mavar2 : <type de donnée>;
  ...
procedure MaProc1;
begin
  <instructions>;
  ...
end;

function MaFonct1;
begin
  <instructions>;
  ...
end;

begin
  <instructions>;
  maproc1;
  mavar1:=MaFonct1;
  ...
end. 

La première partie (Program, Var), vous connaissez presque. On a simplement ajouté deux choses :

• uses: Indique qu'on utilise des fonctions et outils contenus dans d'autres fichiers de programme (nommés des unités) que celui dans lequel on travaille.
• Types: Cette clause sert à définir des types de données particulières.
• procedure et function: On verra plus tard. L'essentiel est de savoir que ces procédures et fonctions sont situées AVANT le bloc principal begin/end.

En attendant, essayez ça :

Program MonPremierProg;

var
  s : string;

begin
  s := 'Salut à tous !';
  writeln(s);
  readln;
end. 

En Turbo Pascal, taper le texte et lancer la compilation (F9). 
En Delphi 4, nous avons un problème, car cet environnement est prévu pour générer des applications graphiques, et le modèle d'application console n'est pas disponible en Delphi 4 :

• Fichier/Tout fermer
• Fichier/Nouveau
• Dans l'onglet application, choisir "texte", et taper le texte du programme
• Une fois le texte tapé, Fichier/Enregistrer, choisir un répertoire sur votre disque et taper "crt1.dpr". Ensuite cliquer sur le bouton Enregistrer
• Aller à nouveau dans Fichier/Tout Fermer
• Aller dans Fichier/Réouvrir et choisir "crt1.dpr"
• Pour compiler et lancer le programme, choisir Exécuter/Exécuter (ou F9). Pour fermer l'application, appuyer sur la touche Entrée.
• Notre algorithme est le suivant :
  1. Affecter une valeur à une variable nommée S s:='Salut à tous';
  2. Ecrire le contenu de la variable à l'écran Writeln(s);
  3. Lire une touche au clavier Readln;

Procédures et fonctions

Lorsque notre programme s'étoffe un peu, il est hors de question de le décrire séquentiellement, même en indentant, vous imaginez 20000 lignes d'un seul bloc ! D'autre part, il peut être intéressant de définir des sous-programmes exécutant certaines tâches pour pouvoir les réutiliser. C'est précisément ce à quoi servent les procédures et les fonctions. D'ailleurs, vous en avez déjà utilisé dans l'exemple ci-dessus : writeln et readln sont des procédures définies "en standard". 
Imaginons, dans notre exemple précédent, que nous demandions à l'utilisateur de notre programme de saisir des mots, et qu'il nous faille en faire une phrase en les concaténant. On pourrait faire :

Program MonDeuxiemeProg;

var
  s, Phrase : string;

begin
  writeln('Entrez un mot :');
  readln(s);
  Phrase:=s;

  writeln('Entrez un deuxième mot :');
  readln(s);
  Phrase:=Phrase+s
  writeln('Entrez un troisième mot :');
  readln(s);
  Phrase:=Phrase+s;

  writeln('La phrase complète est :');
  writeln(Phrase);
end. 

• J'écris un texte à l'écran (remarquez les "quotes" entourant les chaînes de caractères) pour dire à l'utilisateur ce qu'il doit faire
• je lis ce qu'il tape
• je mets le résultat dans ma variable phrase
• je lui demande de saisir un autre mot, et je lis ce qu'il tape
• je cumule le contenu de phrase avec ce qu'il a tapé dans s (phrase:=phrase+s)
• enfin, j'affiche la phrase complète.

En dehors du fait que c'est un peu répétitif, si je veux insérer une virgule après chaque mot tapé, je devrai le faire trois fois. Nous allons donc définir une fonction qui va faire tout ça une fois pour toute :

Program MonDeuxiemeProg;

function ConstruitPhrase(phrase:string):string;
var s : string;
begin
  readln(s);
  ConstruitPhrase:=phrase+', '+s;
end;

var
  Phrase : string;
begin
  Phrase:='';  {initialiser à chaîne vide}
  {premier mot}
  writeln('Entrez un mot :');
  Phrase:=ConstruitPhrase(Phrase);

  {deuxième mot}
  writeln('Entrez un deuxième mot :');
  Phrase:=ConstruitPhrase(Phrase);

  {troisième mot}
  writeln('Entrez un troisième mot :');
  Phrase:=ConstruitPhrase(Phrase);

  {résultat}
  writeln('La phrase complète est :');
  writeln(Phrase);
end. 

Remarquez les commentaires entre accolades. Ce texte est ignoré du compilateur. 
Remarquez aussi l'initialisation de la variable phrase. Ceci est extrêmement important, car lorsqu'un programme démarre, les variables sont dans un état "indéfini" et peuvent contenir n'importe quoi. Ainsi la première fois qu'on appelle notre fonction, il faut bien qu'on lui envoie une chaîne vide (réflechissez voyons !!). La déclaration a été descendue juste au-dessus du begin de début, pour lever toute ambiguïté. 
En effet, les variables, fonctions et procédures ne sont visibles que si elles sont situées au-dessus du code qui les appelle.

Déclaration de fonction

J'ai donc créé la fonction suivante :

function ConstruitPhrase(phrase:string):string;
var s : string;
begin
  readln(s);
  ConstruitPhrase:=phrase+', '+s;
end;

ConstruitPhrase est le nom. 
Vient ensuite le paramètre (phrase:string) qui permet "d'envoyer" une donnée à la fonction. Celle-ci est de type chaîne de caractères. 
Ensuite, après les deux points, j'indique que ma fonction doit me retourner une chaîne de caractères. 
Cette fonction prend donc ce que je lui donne (Phrase), ajoute une virgule, puis ce que vient de taper l'utilisateur. On indique que c'est ce résultat qui doit être renvoyé en le stockant dans une "variable" qui est le nom de la fonction : ConstruitPhrase:=phrase+', '+s;. 
On aurait pu aussi, en Delphi, utiliser le mot Result au lieu du nom de la fonction : result:=phrase+', '+s;.

Utilisation de fonctions

Pour utiliser la fonction, il suffit de citer son nom en lui indiquant le paramètre qu'elle demande :

ConstruitPhrase(Phrase,s);

Sauf que puisque c'est une fonction, je doit récupérer le résultat, que je stocke dans ma variable phrase :

Phrase:=ConstruitPhrase(Phrase);

En clair, j'appelle la fonction en lui donnant ce que contient Phrase, et elle me renvoie Phrase augmenté d'une virgule et d'un mot tapé par l'utilisateur. Remarquez que la variable s n'est plus déclarée en haut du programme, mais localement à la fonction, car je ne m'en sers que dans cette fonction. On ne peut pas l'utiliser en dehors. Une procédure est très similaire, sauf qu'elle ne renvoie rien. On aurait pu s'en sortir quand même, car il est possible de faire en sorte que le paramètre que l'on passe puisse nous revenir modifié : il s'agit d'un passage de paramètre par adresse. La syntaxe serait la suivante :

[...]
procedure ConstruitPhrase(var phrase:string);
var s : string;
begin
  readln(s);
  phrase:=phrase+', '+s;
end;

begin
  Phrase:='';  {initialiser à chaîne vide}
  {premier mot}
  writeln('Entrez un mot :');
  ConstruitPhrase(Phrase);
  [...]
end. 

Dans ce cas, je passe Phrase en paramètre, la procédure travaille dessus, la modifie, et le résultat m'est renvoyé. Cela est possible grâce au mot-clé var indiqué avant le paramètre. En fait, la procédure travaille sur la même variable (même si le nom aurait pu être différent) que celle du programme principal.

Article écrit par Thierry Cornu

A voir également