Compréhension
Les unités peuvent dépendre et se référencer mutuellement. Lorsqu’une unité en référence une autre, l’unité référencée peut être déclarée soit dans la section interface, soit uniquement dans la section implementation. Voici les différences entre les deux méthodes :
Déclaré dans interface (référence côté interface) : vous pouvez définir de nouveaux éléments publics (procédures, types personnalisés…) visibles de l’extérieur à partir du contenu de l’unité référencée, accessibles par toutes les autres unités du projet.
Déclaré uniquement dans implementation (référence côté implémentation) : la portée est limitée. Les identifiants de l’unité référencée ne sont utilisables que dans le code d’implémentation de l’unité courante et ne sont pas accessibles depuis l’extérieur.
Exemple
Ce code n’est qu’une démonstration. Le lecteur n’a pas encore étudié les classes, il suffit de saisir le concept pour l’instant.
Créer un nouveau fichier d’unité Classes.pas
unit Classes;
{$mode objfpc}{$H+}
interface
type
TObject=class;
TComponent=class(TObject)
constructor Create(AOwner:TComponent);virtual;
end;
TObject=class
destructor Destroy;virtual;
end;
implementation
constructor TComponent.Create(AOwner:TComponent);begin end;
destructor TObject.Destroy;begin end;
end.Puis référencer cette unité dans AnotherUnit.pas
unit AnotherUnit;
{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
interface
uses
Classes;
// La classe TComponent est définie dans l’unité Classes, il faut donc référencer Classes dans la section interface
procedure DoSomethingWithComponent(var C: TComponent);
implementation
uses SysUtils; // SysUtils référencé uniquement dans la section implementation
procedure DoSomethingWithComponent(var C: TComponent);
begin
// FreeAndNil provient de SysUtils et n’est appelé que dans le code d’implémentation ; il suffit de le référencer dans implementation
FreeAndNil(C);
end;
end.Langage du code : JavaScript (javascript)Remarques
1 Les dépendances circulaires bidirectionnelles sont interdites dans la section interface
Il est interdit que deux unités se référencent mutuellement dans leurs sections interface respectives en même temps.
Principe : Lors de l’analyse de l’interface d’une unité, le compilateur doit résoudre complètement toutes les unités dépendantes listées dans la clause uses de la section interface de cette unité. Pascal respecte strictement cette règle, ce qui apporte deux grands avantages :
Compilation plus rapide ; le compilateur détermine automatiquement quelles unités doivent être recompilées sans gestion manuelle de scripts de build Makefile complexes. Il n’est pas nécessaire de recompiler l’intégralité du projet après modification du code, tout en garantissant la mise à jour synchronisée de toutes les dépendances.
2 Les dépendances circulaires sont autorisées dans la section implementation
Une dépendance circulaire est valide à condition qu’au moins une des deux unités ne référence l’autre que dans sa section implementation.
Exemple : L’unité A référence l’unité B dans sa section interface, tandis que l’unité B ne référence l’unité A que dans sa section implementation. Cette structure circulaire bidirectionnelle est entièrement prise en charge par le compilateur.