CyBWarrior

1. Unités utilisateurs

Une unité, qu’est ce que c’est ? En fait, c’est un fichier où sont regroupées des procédures,
fonctions, variables, constantes et types directements utilisables par le programmeur.

D’ailleurs, on vous l’a caché, mais vous utilisez déjà une unité : system.

Comme son nom l’indique, cette unité est l’unité système de Turbo Pascal. On retrouve des fonctions
comme write, writeln, read, readln…

Bien que cette unité soit tout de même très complete (les petits programmes précédents sont là
pour le prouver), on a parfois besoin de fonctions suplémentaires pour pouvoir réaliser des taches
plus évoluées.

C’est pourquoi Turbo Pascal est fourni avec bien d’autres unités permettant de faire face à presque
toutes les situations qu’un programmeur peut rencontrer.

Les voici :

• Crt : conrôle du mode vidéo, gestion des codes géographiques des touches, des fenêtres
  et du son.


• Dos : système d’exploitation


• Graph : fonctions graphiques (cercles, lignes…)


• Graph3 : fonctions graphiques de Turbo Pascal 3.0 : gestion de la fameuse Tortue


• Overlay : sert plus ou moins pour la gestion matérielle


• Printer : gestion du port d’impression (LPT1) à l’aide d’un fichier texte


• System : couvre la quasi-totalité des opérations d’entrée-sortie (cf. ci-dessus)


• Turbo3 : permet d’assurer la compatibilité des programmes écrit avec Turbo Pascal
  3.0


• WinDos : idem à Dos, mais plus complet

Les unités ayant rapport avec Turbo Vision ont été omises volontairement.

Si on choisi d’utiliser une des unités ci-dessus, il faut y faire référence dans le programme,
à l’aide de uses, juste après program, et avant la déclaration des label.
Si on utilise plusieurs unités, on les séparera par des virgules.

Exemple : l’unité Crt comporte la fonction KeyPressed, qui permet de tester
si une touche du clavier à été pressée.

On écrira donc :

Program MyProg;

Uses Crt;           { On utilise l’untité Crt }
Begin

  Repeat

    write(’Appuyez sur une touche pour stopper l »écriture de ce stupide message!’);

  Until KeyPressed; { On utilise KeyPressed, de l’unité Crt }

End.

Ormis l’unité system qui est incluse d’office, toutes les unités que vous utiliserez
devront être déclarées ainsi.

Unités utilisateurs

Le Turbo Pascal a comme avantages par rapport au QBasic qu’il est un langage beaucoup plus structuré.
Il permet entre autre de faire de la programmation modulaire.

En d’autres mots, un programeur qui utilise fréquemment certaines fonctions peut les régrouper
dans une unité qu’il pourra appeller dans chacun des programmes qui en aura besoin.

La programmation modulaire n’a que des avantages : imaginez que vous utilisiez pas mal de fonctions
(plus d’une dizaine). Vous les regroupez toutes dans une même unité. Puis, dans plusieurs programmes
vous utilisez cette unité. Déjà, plus besoin de faire des copier/coller pour inclure les même
fonctions. Mais le plus fort arrive : après plusieurs programmes, vous vous rendez compte qu’en fait,
le code que vous utilisez est tout faux! Pas de panique, il suffit juste de corriger l’unité et
de recompiler les programmes dépendents, au lieu de corriger chaque programme comme on l’aurait
fait en Basic…



La création d’une unité n’est pas tellement plus compliquée que celle d’un programme ordinaire.

Voici le squelette d’une unité :

Unit Nom    {Nom de l’unité}

Interface          {Partie « publique »}

  Uses Unité1, Unité2;
  Const Const1 : Type = Valeur;

        Const2 : Type = Valeur;
  Types Type1

        Type2
  Var Var1 : Type;

      Var2 : Type;
  Procedure Procedure1(Arg1,Arg2);       {Déclarations des procédures & fonctions}

  Function Function1(Arg1,Arg2) : Type;  {pouvant être utilisées par les programmes}
Implementation     {Partie « privée »}

  Uses Unité1, Unité2;
  Label Label1, Label2;
  Const Const1 : Type = Valeur;

        Const2 : Type = Valeur;
  Types Type1

        Type2
  Var Var1 : Type;

      Var2 : Type;
  Procedure Procedure1(Arg1,Arg2);

  Var pVar1 : Type;

      pVar2 : Type;

  Begin

    [Instructions]

  End;
  Function Function1(Arg1,Arg2) : Type;

  Var pVar1 : Type;

      pVar2 : Type;

  Begin

    [Instructions]

  End;
Begin        {Initialisation}

  [Instructions]

End.

Quelques petites explications :

• Unit : c’est le nom de l’unité. Contrairement au program dans un programme,
  Unit est obligatoire


• Interface : c’est la partie publique de l’unité. C’est à dire que toutes les constantes,
  types, variables, procédures et fonctions seront accessibles par le programme utilisateur.
  
  En ce qui concerne les procédures et les fonctions, il ne faut spécifier que leurs
  déclarations, les procédures et fonctions proprements dites étant écrites dans la partie
  Implementation


• Implementation : c’est la partie privée. Les constantes, types, variables, procédures
  et fonctions ne sont utilisables que par l’unité elle même, à part les procédures et fonctions
  déclarées dans la partie Interface.


• begin…end. : comme pour un programme, c’est le coeur de l’unité. Ça peut
  paraitre étrange, puiqu’une unité n’a pas pour vocation d’être executée. En fait, cette
  partie sert surtout pour une éventuelle initialisation de divers paramêtres.
  
  Même si vous n’avez pas prévu une telle étape, vous devez quand même l’inclure.

Pour mieux comprendre, voici une unité regroupant quelques fonctions permetant d’effectuer des
calculs concernant la puissance et l’energie :

unit Electro;

Interface

  Const PermAir : Real = 1;           {Perméabilité relative}

        PermFer : Real = 2500;

        PermNickel : Real = 250000;

        PermVide : Real = Pi * 4E-7;
        ChargElec : Real = -1.6E-19;  {Charge électron}
  Function Puissance(U, I : Real) : Real;     {Puissance}

  Function EnergiePT(P, T : Real) : Real;     {Energie en fonction de la puissance

       et du temps}

  Function EnergieUIT(U, I, T : Real) : Real; {Energie en fonction de U, I et T }
Implementation

  Function Puissance(U, I : Real) : Real;

  begin

    Puissance := U * I;

  end;
  Function EnergiePT(P, T : Real) : Real;

  begin

    EnergiePT := P * T;

  end;
  Function EnergieUIT(U, I, T : Real) : Real;

  begin

    {On fait appel aux fonctions déjà établies }

    EnergieUIT := EnergiePT(Puissance(U, I), T);

  end;
begin

  {Pas d’initialisation}

end.

Cette unité n’est pas directement utilisable. Il fois maintenant la compiler, de la même façon
qu’un programme, en appuyant sur la touche F9.

Ici, le fichier pondu ne sera pas du type .EXE, mais .TPU.

En géneral, les fichiers TPU sont regroupés dans un unique répertoire, s’appelant Units.

Le programme ci-dessous montre comment utiliser cette nouvelle unité :

Program TestUnit;

Uses Electro;
Var U : Real;

    I : Real;

    t : Real;
Begin

  writeln(’*** Calcul de l »énergie électrique avec l »unité ELECTRO ***’);

  write(’U (en volts)    = ‘);

  readln(U);

  write(’I (en ampères)  = ‘);

  readln(I);

  write(’t (en secondes) = ‘);

  readln(t);

  writeln(’La puissance dissipée est de ‘, EnergieUIT(U, I, t), ‘ joules.’);

End.

Series Navigation

«Turbo Pascal – Procédures et fonctionsTurbo Pascal – Les tableaux»