Classi ed Oggetti: le proprietà

Le proprietà sono simili ai campi di un oggetto. La differenza tra i campi e le proprietà sta nel fatto che i primi fanno riferimento a delle locazioni di memoria mentre le seconde possono definire delle azioni per l’accesso in lettura e scrittura del loro contenuto. La sintassi di dichiarazione di una proprietà è il seguente

Property NomeProprieta[Indici]:
Tipo index CostanteIntera
Specificatori;

NomeProprieta è, neanche a dirlo, un identificatore riconosciuto valido che identifica la proprietà.

Indici è facoltativo ed è utilizzato nella dichiarazione di proprietà di tipo array ed indica una sequenza di dichiarazioni di parametri del tipo identificatore1, identificatore2 : tipo separate da punti e virgola.

Anche Index CostanteIntera è facoltativo e serve definire degli specificatori di indice utili per condividere gli stessi metodi di accesso durante la rappresentazione di valori differenti.

Specificatori è una sequenza dei seguenti specificatori: read, write, stored, default, nodefault, implements. In ogni dichiarazione di proprietà è necessario indicare almeno uno specificatore read o write.

N.B. Non è possibile utilizzare nelle proprietà l’operatore @ ne possono essere passate come parametri var; questo perchè non è detto che la proprietà esista in memoria, la potrebbe aver un metodo read che recupera il valore per esempio da un database o da altra struttura di dati.

Per gli specificatori di accesso read e write possiamo dire che questi possono fare riferimento a metodi o a campi. Nel caso di metodi, questi dovranno essere definiti nella stessa classe in cui è stata dichiarata la proprietà. Per lo specificatore read nel di un metodo, questo dovrà essere una funzione senza parametri il cui tipo restituito sia dello stesso tipo della proprietà. Per i metodi relativi allo specificatore write, questi dovranno essere procedure che abbiano un solo parametro d’ingresso dello stesso tipo della proprietà.

Quello che segue è un esempio do dichiarazione di proprietà

Property TimeOut : Cardinal read GetTimeOut write SetTimeOut;

La dichiarazione dei metodi degli specificatori read e write è la seguente

Function GetTimeOut : Cardinal;

Procedure SetTimeOut(Value : Cardinal);

Il codice riportato potrebbe far parte di un controllo che implementi al suo interno un timer di tipo TTimer che permette di impostare e leggere il valore di intervallo del timer stesso. Avendo la classe TTimer una sua proprietà Interval i metodi dichiarati sopra potrebbo essere implementati come segue considerando che l’istanza della classe TTimer si chiami FTimer

Function TMioControllo.GetTimeOut : Cardinal;

Begin

Result := FTimer.Interval;

End;

Procedure TMioControllo.SetTimeOut(Value : Cardinal);

Begin

If Value <> FTimer.Interval then

FTimer.Interval := Value;

End;

Quando tra gli specificatori in una dichiarazione di proprietà compare solamente lo specificatore read, la proprietà sarà di sola lettura e di sola scrittura nel caso compaia solamente lo specificatore write. Un esempio di dichiarazione di proprietà sola lettura

Property TimeElapsed : Boolean read FTimeElapsed;

Come visto all’inizio della trattazione delle proprietà, queste possono contenere nella dichiarazione dei parametri aggiuntivi come una sequenza di dichiarazione di parametri. In questo caso abbiamo a che fare con proprietà indicizzate che possono rappresentare elementi di un elenco (TStringList.Items), controlli figli o i pixel di una bitmap.

Ecco alcune dichiarazioni di proprietà array (dal manuale del linguaggio)

Property Objects[Index : Integer] :
TObject read GetObject write SetObject;

Property Pixels[X, Y : Integer] :
TColor read GetPixel write SetPixel;

Property Values[const Name : string] :
string read GetValue write
SetValue;

Il formato dell’elenco di parametri è lostesso di quello utilizzato nella dichiarazione di procedure e funzioni eccezion fatta per le parentesi quadre al posto delle tonde. Abbiamo praticamente a che fare con degli array dove però mentre nel vero tipo array gli indici possono essere di tipo ordinal solamente per quanto riguarda le proprietà array questi possono essere di qualsiasi tipo.

Le proprietà array non ammettono negli specificatori di accesso dei campi, ma solamente dei metodi. Questo per via degli indici che vengono automaticamente passati al metodo che si occuperà di recuperare o di scrivere i dati all’indice richiesto. Un metodo per lo specificatore read deve necessariamente essere una funzione che accetta lo stesso numero e tipo di parametri elencati nella lista degli indici della proprietà, passatigli nello stesso ordine; in oltre il tipo restituito dalla funzione dovrà essere dello stesso tipo della proprietà. Il metodo dello specificatore write dovrà essere una procedura che accetti come parametri lo stesso numero e tipo di parametri elencati nella lista degli indici della proprietà, passatigli nello stesso ordine ed in più il classico parametro valore contenente il valore da settare nella proprietà. Ecco alcuni esempi di metodi per proprietà array che fanno riferimento ai metodi dell’esempio precedente

Function GetObject(Index : Integer) : TObject;

Function GetPixel(X, Y : Integer) : TColor;

Function GetValue(const Name : String) : String;

Procedure SetObject(Index : Integer; Value : TObject);

Procedure SetPixel(X, Y : Integer; Value : TColor);

Procedure SetValue(const Name, Value : String);

Le proprietà array possono essere accedute come classicamente si accede alla locazione di un array nel seguente modo

Canvas.Pixel[5, 45] := clGreen;

quando si definisce una proprietà array, si ha la possibilità di impostarla come proprietà predefinita della classe a cui appartiene. Ciò permette di accedere alla proprietà specificando immediatamente dopo il nome della classe l’elenco di indici. Per diefinire una proprietà predefinita per un classe occorre specificare dopo la dichiarazione della proprietà la direttiva default. Ad esempio avendo una dichiarazione del tipo

Type TStringArray = Class

Public

Property Strings[Index : Integer] : String …;
default;

…

End;

Supponendo che l’istanza della classe TStringArray si chiami StringArray potremmo accedere alla proprietà Strings della classe nel seguente modo

StringArray[10] := ‘Carlo’;

al posto di

StringArray.Strings[10] := ‘Carlo’;

Per ovvi motivi, una classe può avere solamente una proprietà predefinita.