Unité simple

johann17

Afin d'éviter de réécrire les mêmes instructions, il est possible de les rassembler dans des procédures et des fonctions, voire dans des objets (appelés aussi classes). Les procédures et les fonctions peuvent être rassemblées dans des fichiers de code qu'on appelle les unités. Faire des unités augmente la lisibilité du projet et permet de réduire le nombre de lignes de code dans chacun des fichiers. Ces unités peuvent ensuite être utilisées par plusieurs projets.

La version de Lazarus utilisée est la 0.9.26.

Commentez

- Titre : Unité simple

- Auteur : johann17

- Parution : 4 novembre 2008

- Mise à jour : 4 janvier 2020

- Licence : Copyright ® 2008-2010 johann17. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- Mise en place

- Utilisation dans le projet en cours

- Utilisation dans un autre projet

- Ajouter le fichier au projet

- Utiliser une dépendance relative

Mise en place

Ouvrez un projet dans lequel vous voulez utiliser les procédures, fonctions ou objets que vous voulez rassembler. Allez dans le menu Fichier et cliquez sur Nouvelle unité. Une nouvelle page apparaît dans l'éditeur de code. Vous pouvez dès lors enregistrer le fichier. Donnez-lui un nom évocateur.

Un fichier d'unité est constitué de deux parties, l'interface et l'implémentation. Pour ajouter une procédure ou une fonction, écrivez tout d'abord son prototype dans la partie interface, c'est-à-dire avant le mot-clé implementation. Par exemple, pour définir une fonction qui calcule la factorielle d'un nombre :

function factorielle(n: byte): longint;

Ensuite, mettez le curseur sur la ligne de prototype et appuyez sur Ctrl-Shift+C. L'éditeur de code ajoute automatiquement le corps de la fonction dans la partie implémentation (c'est-à-dire après le mot-clé implementation). En l'occurrence, cela donne :

function factorielle(n: byte): longint;
begin

end;

Il ne reste plus qu'à écrire le code de la fonction, déclarer les variables locales nécessaires, etc. Il est bien entendu possible de déclarer plusieurs procédures et fonctions dans la partie interface et de mettre le corps de ces procédures et fonctions dans la partie implémentation.

Voilà un exemple de code complet pour l'unité créée :

unit UMath;

{$mode objfpc}{$H+}

interface

uses
Classes, SysUtils;

function Factorielle(n: byte): longint;

implementation

function Factorielle(n: byte): longint;
var k: integer;
begin
result := 1;
for k := 2 to n do
result := result*k;
end;

end.

Utilisation dans le projet en cours

Pour utiliser les fonctions et les objets qu'on a définis, il faut ajouter le nom des unités à utiliser dans une clause uses. Supposons qu'on ait écrit une unité UMath et qu'on veuille l'utiliser dans une autre unité (par exemple dans le code d'une fenêtre). On ajoute tout juste après le mot-clé implementation la ligne suivante :

uses UMath;

S'il y a déjà d'autres unités utilisées, on peut faire figurer une liste de nom d'unités séparées par des virgules après le mot-clé uses.

Tout le code qui suivra pourra alors utiliser les fonctions de UMath. Par exemple, si l'on veut que, lorsque l'on clique sur un bouton, le résultat de 6! soit écrit dans un champ texte, on double-clic sur le bouton en question, ce qui affiche l'éditeur de code avec une procédure vide. Dans cette procédure, on rajoute le code suivant :

Edit1.Text := IntToStr(Factorielle(6));

Ce qui a été expliqué fonctionne également pour les procédures et les objets.

Utilisation dans un autre projet

Si l'on ouvre un autre projet, l'unité que l'on vient de créer ne sera pas reconnue par défaut. Il y a alors deux solutions.

Ajouter le fichier au projet

Si le répertoire qui contient l'unité ne va pas bouger, on peut ajouter le fichier de l'unité au projet. Les deux projets auront alors un fichier en commun.

Pour faire cela, allez dans le menu Fichier et cliquez sur Ouvrir. Recherchez le fichier d'unité créé précédemment. Une fois le fichier ouvert dans l'éditeur de code, allez dans le menu Projet et cliquez sur Ajouter le fichier de l'éditeur au projet.

Après avoir rajouté l'unité au projet, Lazarus propose de rajouter le répertoire contenant l'unité ajoutée comme chemin de recherche des unités. Acceptez en cliquant sur Oui.

Enfin, il faut ajouter le nom des unités à utiliser dans les clauses uses où on veut utiliser les fonctions (voir section précédente).

Utiliser une dépendance relative

On peut rajouter une dépendance au projet, en l'occurrence une unité qui sera utilisée lors de la compilation même si elle ne fait pas partie du projet. L'avantage est que l'on peut définir le chemin de manière relative.

Pour faire cela, il faut ouvrir le fichier source du projet (le fichier lpr). Vous pouvez l'ouvrir en allant dans le menu Projet et cliquant sur Afficher le source. Dans la clause uses du projet, ajoutez à la fin de la liste le nom de l'unité suivi du mot-clé in suvi de son chemin relatif. Dans le cas où l'on a deux projets situés dans le même répertoire, et que l'on veut lier le deuxième projet à une unité UMath du premier projet ProjMath, on ajoutera le code suivant :

UMath in '..\projmath\umath.pas'

Ce qui donnera un fichier de projet ressemblant à ceci :

program project1;

{$mode objfpc}{$H+}

uses
{$IFDEF UNIX}{$IFDEF UseCThreads}
cthreads,
{$ENDIF}{$ENDIF}
Interfaces, // this includes the LCL widgetset
Forms
{ you can add units after this }, Unit1, UMath in '..\projmath\umath.pas';

begin
Application.Initialize;
Application.CreateForm(TForm1, Form1);
Application.Run;
end.

Enfin, il faut ajouter le nom des unités à utiliser dans les clauses uses où on veut utiliser les fonctions (voir section précédente).