CyBWarrior

1. Procédures
2. Fonctions
3. Variables globales et variables locales
4. Imbrication de procédures
5. Architecture du programme

Les procédures et fonctions sont des morceaux de code qui peuvent être appellés d’à peu près
n’importe quel endroit du programme.

Une procédure se distingue d’une fonction par le fait qu’elle ne renvoi pas de valeur.

À l’inverse, une fonction en renvoi une…

Procédures

Comme on l’a vu, une procédure est constituée de lignes de code. Qui dit lignes de code, dit bloc
d’instruction. On va donc retrouver le désormais très commun begin…end.

Mais ce n’est pas tout! Une procédure posséde un nom. Par exemple, pour écrire sur l’écran, vous
utilisez write ou writeln selon le cas. Et bien write et
writeln sont les noms des procédures.

Ensuite, une procédure est définit par un mot-clef, qui est tout bêtement procedure.

Enfin, il est rare qu’une procédure soit utilisée tel quel. En général, on lui passe un ou plusieurs
arguments, entre parenthèses. Ex: avec write, l’argument transmis est la chaine de
caractères.

Pour bien voir tout ça, nous allons créer une procédure qui calculera la résistance d’un composant
électrique en étant en connaissance de la tension et de l’intensité. Le résultat sera également
affiché par celle-ci. Les arguments à transmettre seront donc : une variable I pour l’intensité,
et une variable U pour la tension. Nous appelerons la procédure LoiOhm

Voici le programme :

program elec;

procedure LoiOhm(I : Real; U : Real);     { Début de la procédure }

begin

  { La Loi d’Ohm, c’est U=RxI, donc R=U/I }

  write(’La résistance est de ‘, U / I, ‘ Ohms.’);

end;                                      { Fin de la procédure }
begin

  LoiOhm(15, 240);             { Appel de la procédure. U=220 et I=15 }

end.

Voyons en détails :

• procedure LoiOhm(I : Real; U : Real); : c’est le début de la procédure. On
  retrouve le mot-clef procedure. Ensuite, c’est le nom de la procédure. Entre
  parenthèses, c’est les arguments. Il ne faut pas oublier de spécifier leurs types. Ils doivent
  être séparés par des points-virgules. En parlant de points-virgules, la ligne doit en comporté
  un à sa fin.
  
  Remarque : on aurrait pu écrire cette ligne à la place : procedure LoiOhm(I, U : Real);
  
  Ainsi, on ne sécifie qu’une seule fois le type des variables.


• Ensuite, il n’y a plus de mystères : on retrouve un bloc d’instruction begin…end;,
  et à l’intérieur, on calcul et on affiche le résultat.

Maintenant, on a encore besoin de la loi d’Ohm à un autre endroit de notre programme. Mais cette
fois, on veut avoit juste le résultat et afficher le résultat à notre guise, mais hors procédure.

Plusieurs méthode sont possibles. Nous allons d’abord voir comment opérer avec une 3^ème
variable passée en argument. Nous l’appelerons R, comme Résistance. Elle aussi est
du type Réél. On peut donc écrire :

program elec;

var MonResultat : Real;
procedure LoiOhm(I, U, R : Real);

begin

  R := U / I;

end;
begin

  writeln(’Avant -> MonResultat = ‘, MonResultat);  { Sortie -> 0 }

  LoiOhm(15, 250, MonResultat);                     { On passe notre

      variable en argument}

  writeln(’Après -> MonResultat = ‘, MonResultat);  { Sortie -> 0 }

end.

Vous remarquez que la sortie est toujours égale à 0. Pourquoi ?

Il faut spécifier que R est une variable dans la procédure, à l’aide du mot-clef
var. Notre exemple ainsi modifié devient :

program elec;

var MonResultat : Real;
procedure LoiOhm(I, U : Real; var R : Real);        { Utilisation du mot-clef VAR }

begin

  R := U / I;

end;
begin

  writeln(’Avant -> MonResultat = ‘, MonResultat);  { Sortie -> 0 }

  LoiOhm(15, 250, MonResultat);                     { On passe notre

      variable en argument }

  writeln(’Après -> MonResultat = ‘, MonResultat);  { Sortie -> 16.66… }

end.

Cette syntaxe ne vous rappelle rien ? Et oui, il se passe la même chose que lors de l’utilisation
de read : on passe une variable à la procédure et celle-ci nous la renvoi modifiée.

Fonctions

Nous allons maintenant modifier notre exemple précédent pour qu’il fonctionne avec une fonction.

L’utilisation de fonctions n’a rien de plus compliqué : ici, on affectera le résultat non pas
à une variable, mais à la fonction.

Par conséquent, la fonction possédera un type (ici, Real).

program elec;

var MonResultat : Real;
function LoiOhm(I, U : Real) : Real;                 { LoiOhm est Real }

begin

  LoiOhm := U / I;                                   { Affectation du résultat

       à la fonction }

end;
begin

  writeln(’La résistance est de ‘, LoiOhm(15, 240)); { Appel de la fonction }

end.

Remarques :

• De la même façon qu’une procédure, une fonction peut aussi modifier des variables transmises
  en arguments


• Bien qu’une fonction ressemble à une variable, ce n’en est pas une. On ne peut donc pas
  écrire des choses du genre :
  

  
  
  program CalcCercle;
  
  function Aire(Rayon : Real) : Real;
  
  begin
  
    Aire := Rayon;          { Pas bon }
  
    Aire := Aire * Rayon;   { Pas bon }
  
    Aire := Aire * Pi;      { Pas bon }
  
  end;
  begin
  
    writeln(’L »aire d »un cercle de rayon 5 est de ‘, Aire(5));
  
  end.
  
  

Variables globales et variables locales

Pour l’instant, toutes les variables que nous avons déclarées étaient globales.

Une variable globale, c’est une variable qui peut être accédées par toutes les procédures et
fonctions du programme.

Dans l’exemple si dessous, la variable VarGlob est accessible par la procédure et
le programme principal :

var VarGlob : integer;

procedure SousProg;

begin

  VarGlob := VarGlob + 1; { VarGlob = 10 + 1 }

  writeln(VarGlob);       { Sortie -> 11 }

end;
begin

  VarGlob := 10;

  writeln(VarGlob);       { Sortie -> 10 }

  SousProg;

end.

Maintenant, nous allons déclarer cette même variable de façon quel soit inaccessible par la procédure
SousProg :

procedure SousProg;

begin

  VarGlob := VarGlob + 1; { Une Erreur se produit ! }

  writeln(VarGlob);       { Error 3 : Unknow Identifer }

end;

var VarGlob : integer;    { VarGlob est maintenant locale }

begin

  VarGlob := 10;

  writeln(VarGlob);       { Sortie -> 10 }

  SousProg;

end.

La meilleur preuve qu’elle est inaccessible, c’est qu’une erreur est provoquée si on essaye de
lancer le programme.

On peut aussi faire l’inverse, c’est à dire rendre une variable accessible uniquement par une
procédure, pour que le programme principal ne puisse pas l’utiliser :

procedure SousProg;

var VarLoc : integer;  { VarLoc est accessible uniquement par SousProg}

begin

  VarLoc := 50;

  writeln(VarLoc);     { Sortie -> 50 }

end;

begin

  SousProg;

  writeln(VarLoc);     { Error 3 : Unknow Identifer }

end.

Attention! Dans les procédures et les fonctions, les variables sont toujours réinitialisées
à chaque appel de la dite procédure ou fonction.

Imbrication de procédures

De la même façon qu’il est possible d’imbriquer des boucles dans d’autres boucles, il est possible
d’imbriquer des procédures dans des procédures.

Cette sous-procédure ne peut être appellées que par la procédure de niveau supérieur. De la
même façon, une sous-procédure ne peut appeler que d’autres sous-procédures de la procédure de
niveau supérieur, ou des procédures principales.

procedure Proc;

  procedure SousProc;

  begin

    writeln(’Hello! Ici, nous sommes dans la sous procédure de Proc’);

  end;

begin

  writeln(’On est dans la procédure Proc’);

  SousProc;

end;

begin

  writeln(’Corps du programme’);

  Proc;

end.

Architecture du programme

Il est temps de dresser un squelette d’un programme, avec nos connaissances actuelles :

program nom;                           {Nom du programme}

label label1, label2;                  {Labels}
const const1 : Type = valeur;          {Constantes}

      const2 : Type = valeur;
var gVar1 : Type;                      {Variables globales}

    gVar2 : Type;
procedure procedure1(Arg1,Arg2);       {Procédures}

var pVar1 : Type;                      {Variables locales}

    pVar2 : Type;

begin

  [Instructions]

end;
function function1(Arg1,Arg2) : Type;  {Fonctions}

var pVar1 : Type;                      {Variables locales}

    pVar2 : Type;

begin

  [Instructions]

end;
var pVar1 : Type;                      {Variables locales}

    pVar2 : Type;
begin                                  {Procédure principale}

  [Instructions]

end.

Series Navigation

«Turbo Pascal – Les bouclesTurbo Pascal – Les unités»