Abbiamo visto in precedenza un esempio di applicazione console. Ora vedremo un altro
esempio riguardante però un'applicazione per Windows ovvero quello che ci interessa di
più e per cui Delphi è nato.
Questo è il codice:
Program Editor;
Uses
Forms,
REAbout in 'REABOUT.PAS' {AboutBox},
REMain in 'REMAIN.PAS' {MainForm};
{$R *.RES}
Begin
Application.Title := 'Text Editor';
Application.CreateForm(TMainForm, MainForm);
Application.Run;
End.
Come potete vedere il codice è leggermente diverso, come contenuto, da quello che
abbiamo visto in precedenza ma la struttura è la stessa. Abbiamo una intestazione del
programma "Program Editor", una clausola "Uses"
contenente i riferimenti per l'inclusione di altre unit nel programma, ed il blocco
principale "Begin..End.". Solitamente in questo blocco sono
presenti solamente chiamate a metodi dell'oggetto Application del progetto. Ogni progetto
Delphi ha una variabile Application di tipo TApplication (o come vedremo
TWebApplication, TserviceApplication in base al tipo di progetto scelto) che permette di
accedere alle proprietà e metodi base dell'applicazione stessa.
Quindi la struttura di un file di progetto di Delphi può essere riassunta così:
Program NomeProgramma; //Intestazione del programma
Uses Unit1, Unit2, …, UnitN; //Clausola uses per l'inclusione
di altre unit nel programma
{$R *.RES}
Begin //Blocco principale del progetto
...
End.
Struttura e Sintassi delle unit
Ogni unit è contenuta in un file .PAS e può contenere dichiarazioni di tipi,
variabili, funzioni, procedure. Come il file di progetto, anche la unit inizia con una
intestazione (che ha inizio con la parola chiave Unit e dal nome della unit stessa)
seguita da altre sezioni come riportato di seguito:
Unit Unit1; {Intestazione}
Interface
Uses {Lista di unit}
Implementation
Uses {Lista di unit}
{Codice per la definizione di tipi,
variabili, funzioni e procedure}
Initialization
{Codice di inizializzazione della unit}
Finalization
{Codice di finalizzazione della unita}
End.
Come si può vedere abbiamo: una sezione definita "Interface" che
conterrà le definizioni di tipi, variabili, dichiarazioni di funzioni e procedure che si
vuole siano accessibili da altre unit; una sezione definita "Implementation"
che conterrà il codice "privato" della unit, non accessibile dall'esterno,
consistente in dichiarazioni di tipi, variabili, funzioni, procedure e il codice di
implementazione delle funzioni o procedure stesse. Le sezioni "Initialization"
e "Finalization" sono facoltative e servono ad eseguire codice per
l'inizializzazione della unit e per la finalizzazione della unit rispettivamente al
momento del caricamento della unit stessa e al momento del rilascio. Se in una clausola
uses sono presenti più di una unit, la sequenza con cui saranno eseguite le sezioni
"Initialization" sarà la stessa di quella della clausola uses. Per
esempio se la clausola uses riporta
uses unit1, unit2, unit3;
l'ordine con cui verranno eseguite le sezioni di inizializzazione sarà: unit1, unit2,
unit3. Per quanto riguarda le sezioni di finalizzazione l'ordine sarà inverso rispetto a
quello di inizializzazione. Con riferimento all'esempio di prima avremo: unit3, unit2,
unit1.
Riguardo alla clausola uses di un programma o libreria, come nell'esempio di programma
Windows che abbiamo visto in precedenza, c'è la possibilità di indicare il percorso in
cui si trova la unit da includere nel progetto specificando dopo il nome della unit la
parola chiave "in" seguita dal percorso assoluto o relativo racchiuso tra
apici. Per esempio mettiamo che la unit "Unit1.pas" nel seguente progetto si
trovi in un percorso diverso da quello in cui sitrova il file principale del progetto
avremo:
Program Program1;
Uses Unit1 in 'c:progettimioprogetto2Unit1.pas';
…
In questo caso ho fatto riferimento ad un percorso assoluto ma avrei potuto specificare
un percorso relativo. Per esempio, se il Program1 si trovasse nella directory
"c:progettimioprogetto1" e all'interno ci fosse una directory chiamata
"extra" in cui ripongo delle unit, nell'esempio precedente avrei potuto
scrivere:
Uses Unit1 in 'c:progettimioprogetto1extraUnit1.pas';
oppure
Uses Unit1 in '..extraUnit1.pas';
considerando sempre il fatto che il file principale del programma si trovi in
"c:progettimioprogetto1".
Un'ultima cosa riguardo le unit. Come è facilmente intuibile, nella clausole uses di
una unit posso fare riferimento ad altre unit. In questo caso bisogna fare attenzione ai
"riferimenti circolari", ovvero fare attenzione a non far riferimento in una unit
ad un'altra che a sua volta si riferisce alla prima. Leggendo potrebbe venire in mente che
chi sta scrivendo questo corso sia un pazzo. In effetti è più semplice capire ciò che
ho detto con un esempio.
Program Program1;
Uses Unit1;
Const Pippo = Pluto;
...
Unit Unit1;
Interface
Uses Unit2;
Const Pluto = Paperino;
...
Unit Unit2;
Interface
Const Paperino = 1;
...
Nell'esempio precedente non ci sono problemi di "riferimenti circolari" e
tutto funziona bene.
Program Program2;
Uses Unit1;
Const Pippo = Pluto;
...
Unit Unit1;
Interface
Uses Unit2;
Const Pluto = Paperino;
...
Unit Unit2;
Interface
Uses Unit1;
Const Paperino = 1;
...
In questo esempio invece abbiamo un problema di "riferimento circolare".
Infatti la Unit1 fa riferimento nella sua clausola uses alla Unit2 che a sua volta fa
riferimento nella sua clausola uses alla Unit1. Al momento della compilazione del progetto
questo errore viene segnalato dal compilatore. Nel caso in cui sia necessario utilizzare
questa struttura di progetto, per evitare un "riferimento circolare" tra la
Unit1 e la Unit2 è sufficiente spostare la clausola uses con il riferimento alla Unit 1
della Unit2 nella sezione "Implementation" come riportato di seguito:
Program Program2;
Uses Unit1;
Const Pippo = Pluto;
...
Unit Unit1;
Interface
Uses Unit2;
Const Pluto = Paperino;
...
Unit Unit2;
Interface
Const Paperino = 1;
Implementation
Uses Unit1;
...
Se abbiamo due unit che dichiarano una variabile, costante, tipo, routine con lo stesso
nome, possiamo accedere alla variabile, costane, tipo, routine che ci interessa fornendo
anche il nome della unit nel modo seguente:
Unit Unit1;
Interface
Const Pluto = 1;
...
Unit Unit2;
Interface
Const Pluto = 2;
...
Uses Unit1, Unit2;
...
Topolino := Unit1.Pulto;
//La variabile Topolino assumerà valore 1
Topolino := Unit2.Pluto;
//La variabile Topolino assumerà valore 2
...
N.B. Chi conosce già il C++, può notare che le unit del Delphi o più in generale
dell'Object Pascal corrispondono ai "NameSpace" e che la clausola uses
corrisponde alla direttiva "#Include".
