I tipi (parte seconda)

I tipi real

I tipi real definiscono insiemi di numeri che possono essere rappresentati con la notazione in virgola mobile.

I tipi real fondamentali sono riportati di seguito

Il tipo real generico equivale al double.

Seguono alcune considerazioni sui tipi real fondamentali

• Il tipo Real48 viene mantenuto per compatibilità con il tipo real delle versioni precedenti di Object Pascal. Non essendo un tipo che utilizza un formato di memorizzazione non nativo per le CPU intel determina prestazioni più lente.
• Extended è il tipo real che permette maggiore precisione ma a sua volta è meno portabile.
• Il tipo Comp (computazionale) è nativo per le CPU Intel e rappresenta un integer a 64 bit. Pur essendo un tipo integer viene classificato come real in quanto non si comporta come tipo ordinal; non è infatti possibile incrementare o decrementare un valore comp. Viene mantenuto per compatibilità con le versioni precedenti. Al suo posto si consiglia l’uso del tipo Int64.
• Currency è un tipo di dati che viene utilizzato per i calcoli valutari poiché ne riduce al minimo gli errori di arrotondamento. È caratterizzato da punto decimale fisso e viene memorizzato come un integer a 64 bit scalato, con le ultime quattro cifre meno significative che rappresentano i decimali. Valori di questo tipo vengono automaticamente moltiplicati o divisi per 10000 quando vengono usati in espressioni con altri tipi real.

---

I tipi String

L’Object Pascal possiede, a differenza di altri linguaggi come ad esempio il C ed il C++, tipi di dati dedicato alla gestione dell stringhe. I tipi string supportati dall’Object Pascal sono i seguenti

AnsiString è il tipo preferito per la maggior parte della applicazioni. A volte viene anche chiamato LongString.

I tipi string possono essere mischiati nelle assegnazioni e nelle espressioni in quanto il compilatore effettua automaticamente le conversioni del caso. Bisogna invece fare attenzione nel passaggio di parametri alle funzioni ed alle procedure che deve rispettare il tipo dei parametri dichiarati insieme alla funzione o procedura.

Il tipo generico per il tipo string è string. Non si tratta proprio di un tipo ma di una parola chiave del linguaggio che identifica un tipo di dati contenete una stringa. Come stato predefinito la parola chiave string si riferisce al tipo AnsiString (se non è seguita da un numero fra parentesi quadre). È possibile cambiare string in ShortString tramite la direttiva del compilatore {$H-}.

Anche per il tipo string esistono funzioni predefinite come Length che restituisce la lunghezza in caratteri di una stringa e SetLength che ne regola la lunghezza.

Due variabili di tipo string possono essere confrontate tramite gli operatori relazionali. In tal caso il confronto avviene confrontando l’ordinalità dei caratteri che occupano la stessa posizione. Ad esempio la stringa “AB” risulterà minore di “AC”. Confrontando stringhe di differente lunghezza, la dove i caratteri della stringa più lunga non hanno corrispondenza nella stringa più corta, vengono considerati maggiori. Di conseguenza la stringa “AB” risulterà maggiore della stringa “A”.

Una variabile string può essere indicizzata come se si trattasse di un array. I tal caso è possibile accedere i caratteri di una stringa utilizzando la seguente sintassi.

S[i] dove S è una variabile di tipo string e i un intero indicante la posizione all’interno della stringa S.

Per cui, S[2] := ‘A’ assegna alla posizione 2 della stringa S il carattere ‘A’.

Molta attenzione va fatta nella manipolazione delle stringhe tramite la tecnica vista in precedenza in quanto, in presenza di stringhe di tipo AnsiString o WideString che in realtà rappresentano stringhe terminate con null, la sovrascrittura dell’ultimo carattere (il null appunto) potrebbe causare un errore di violazione di accesso.

I tipi Short String

Come visto nella tabella dei tipi string, il tipo ShortString può essere lungo da 0 a 255 caratteri. Mentre la sua lunghezza varia dinamicamente, la memoria che occupa viene allocata staticamente e corrisponde a 256 byte; all’interno del primo byte è riportata la lunghezza in caratteri della stringa. Ne consegue che per ottenere la lunghezza di una stringa ShortString è possibile leggere il valore ordinale del carattere presente alla posizione 0 secondo la rappresentazione ad array. L’operazione Ord(S[0]) è equivalente a Length(S) dove S è una variabile string.

L’Object Pascal supporta anche dei sottotipi di ShortString la cui lunghezza varia da 0 a 255. Questi tipi vengono definiti specificando un numerale tra parentesi quadre dopo la parola chiave string. Per esempio

Type String50 = String[50];

definisce un tipo String50 la cui lunghezza massima è di 50 caratteri. Questo tipo di dichiarazione permette di risparmiare spazio in memoria poiché per contenere un variabile del tipo String50 verranno allocati solamente 51 byte a differenza dei 256 del tipo base ShortString.

I tipi Long String (AnsiString)

Come accennato in precedenza il tipo AnsiString viene anche definito LongString. Il tipo AnsiString rappresenta una stringa allocata dinamicamente la cui lunghezza massima è limitata solamente dalla memoria disponibile. Una variabile di questo tipo non è altro che un puntatore che occupa 4 byte. Il sistema utilizzato, totalmente gestito in maniera invisibile all’utente, è simile ad una lista di caratteri. Ciò permette appunto di avere una lunghezza dipendente solamente dalla memoria disponibile nel sistema. Un’altra caratteristica di questo tipo è che, trattandosi di puntatori, due o più variabili di questo tipo possono far riferimento allo stesso valore senza spreco aggiuntivo di memoria.

I tipi Wide String

L’allocazione di variabili di questo tipo è il medesimo di quello per variabili di tipo AnsiString con la differenza che le stringhe rappresentate utilizzano caratteri UNICODE a 16 bit. Si differenzia solamente per efficienza che risulta minore in quanto non utilizza accorgimenti come il contatore dei riferimenti utilizzato invece dal tipo AnsiString. Questo tipo è utilizzato prevalentemente per la compatibilità con i tipi nelle funzionalità COM.

---

I tipi strutturati

Fanno parte di questa categoria di tipi i Set, gli Array, i Record, i file oltre alle classi ed alle interfacce. Una istanza di tipo strutturato raccoglie sotto di se più valori. I tipi Set possono a loro volta contenere valori di tipo strutturato eccezion fatta per il tipo Set che può contenere solamente valori di tipo ordinale.

Set

Il tipo set implementa quello che in matematica viene definito insieme. Un set può contenere solamente valori dello stesso tipo ordinale senza seguire alcun ordinamento intrinseco. Altresì non ha significato che un elemento sia inserito due volte in un Set. L’intervallo di validità dei valori di un tipo Set dipende dall’intervallo di validità del tipo ordinal utilizzato per creare il Set. Questo tipo ordinale che origina il Set viene chiamato tipo base. Il costrutto utilizzato per dichiarare un tipo Set è il seguente

Set of TipoBase

Esempi di dichiarazione di tipi Set sono i seguenti:

Type TChars = ‘A’..’Z’;

TSetOfChars = Set of TChars;

Per assegnare dei valori a varibili di tipo Set, facendo riferimento all’esempio precedente, si procede come segue:

Var Caratteri : TSetOfChars;

…

Caratteri := [‘A’, ‘F’, ‘B’, ‘T’, ‘X’];

Con analogia alla matematica ed agl’insiemi, un tipo Set può essere vuoto e viene rappresentato con [].

Array

Gli array rappresentano una raccolta indicizzata di elementi tutti appartenenti ad uno stesso tipo che, come per i tipi Set, prende il nome di Tipo Base. A differenza dei tipi Set, un array può contenere, proprio perché indicizzato, più volte lo stesso valore. I tipi base utilizzabili nella dichiarazione di array, possono essere qualsiasi dai tipi ordinal ai tipi string, puntatori, altri array etc. Gli array possono essere dichiarati staticamente o dinamicamente ed essere mono o multi dimensionali. Un array monodimensionale rappresenta un vettore di elementi, mentre array multidimensionali rappresentano matrici di elementi.

Array statici

Il costrutto che si utilizza per dichiarare array statici è il seguente

array [TipoIndice₁, …, TipoIndice_n] of TipoBase;

Il numero di elementi che può contenere un array così definito è dato dal prodotto delle dimensioni dei TipoIndice racchiusi tra parentesi quadre.

Gli array monodimensionali o vettori, hanno un solo TipoIndice come in questo esempio

Type TVettore100 = Array [1..100] of Integer;

In questo esempio è stato definito un vettore che può contenere al massimo 100 valori integer.

Per accedere ai valori di una variabile array come sopra dichiarata si utilizza la sintassi MioVettore[50] dove MioVettore è il nome della variabile di tipo TVettore100 e 50 l’indice dell’elemento 50 all’interno dell’array. Quando si definisce una variabile di tipo array e non si assegnano valori a tutti gli elementi, gli elementi non assegnati vengono comunque allocati e conterranno valori non definiti.

Si possono anche dichiarare array multidimensionali come di seguito

Type TMatrice10X10 = Array [1..10, 1..10] of
Integer;

In questo caso è stato dichiarato un tipo TMatrice10X10 composto da 10 righe e 10 colonne. La dichiarazione precedente equivale a dichiarare un tipo array di array come di seguito

Type TMatrice10X10 = Array [1..10] of Array [1..10] of Integer;

Per accedere i valori di una variabile dichiarata come TMatrice10X10 si procede in maniera simile agli array monodimensionali tranne per il fatto che, essendo questi a più dimensioni, bisogna indicare un indice per ognuna delle dimensioni dell’array. Nel caso dell’esempio precedente MiaMatrice[2, 3], dove la variabile MiaMatrice è di tipo TMatrice10X10, accederà al valore contenuto alla riga 2 colonna 3 della matrice.

In Object Pascal sono definite funzioni per operare con gli indici e le dimensioni degli array statici. Con Low e High si ottiene rispettivamente il limite inferiore e quello superiore del primo tipo dell’array. Con Length si ottiene il numero di elementi nella prima dimensione dell’array.

Array dinamici

A differenza degli array statici, gli array dinamici non hanno dimensioni e lunghezza fisse e quindi la memoria viene riallocata quando si assegna un valore all’array o quando si utilizza la funzione SetLength per impostarne le dimensioni.

Per dichiarare deigli array dinamici si utilizza il costrutto

Type NomeTipo = Array of TipoBase;

Quando si dichara un array dinamico questo non occupa memoria fino a quando non si effettua una chiamata alla funzione SetLength.

Per esempio, se è stata dichiarata una variabile MioArray di tipo TMioArray = Array of Integer per creare effettivamente l’array in memoria effettuando la chiamata SetLength(MioArray, 100), si allocherà memoria per un array di 100 elementi integer. Da ricordare che l’indicizzazione degli array dinamici si basa sempre su integer e comincia da 0. In pratica gli array dinamici sono puntatori similmente ai LongString. Per disallocare un array dinamico, è possibile assegnare alla variabile che lo referenzi il valore Nil oppure passare la variabile stessa alla funzione Finalize; questo verrà disallocato solamente nel caso in cui non siano presenti altri riferimenti ad esso. Array di lunghezza 0 assumono il valore Nil.

Anche per gli array dinamici sono disponibili le funzioni standard Length, Low ed High. Queste restituiscono rispettivamente il numero di elementi dell’array, 0 in ogni caso, e l’indice superiore dell’array. Nel caso di array vuoti High restituisce -1. Interessante notare che si avrà in questo caso High < Low (-1 < 0).

Record

Per fare subito un confronto con altri linguaggi, tra cui C e C++, questo tipo corrisponde ai tipi struct (Struttura). Esso rappresenta un insieme di elementi eterogenei fra loro, ovvero un tipo record può raggruppare in se tipi diversi di elementi. Gli elementi di un record vengono detti campi; nella dichiarazione di un tipo record occorre specificare un nome per il tipo record ed un nome ed un tipo per ciascuno dei suoi campi. Ecco la struttura della dichiarazione di un record

Type NomeTipoRecord = Record

Campo₁ : Tipo₁;

…

Campo_n : Tipo_n;

End;

Come per gli array dinamici, la dichiarazione di una un tipo record, non alloca memoria per i campi in esso contenuti. La memoria viene allocata al momento della dichiarazione di una variabile di quel tipo record.

Un esempio di tipo record è

Type TPersona = Record

Nome : String[40^];

Cognome : String[40];

Eta : Integer;

End;

Per accedere ai campi del record si utilizza la sintassi seguente

NomeVariabile.Nomecampo

Dall’esempio precedente

Var Persona : TPersona;

…

Persona.Nome := ‘Carlo’;

Persona.Cognome := ‘Marona’;

Persona.Eta := 25;

Se si devono accedere più volte i campi del record è possibile utilizzare il costrutto With..do nel modo seguente

With Persona do

Begin

Nome := ‘Carlo’;

Cognome := ‘Marona’;

Eta := 25;

End;

Quando si dichiara un tipo record, si ha la possibilità di inserire nella sua dichiarazione delle varianti alla sua struttura. Queste varianti vanno inserite dopo aver dichiarato tutti i campi del record. L sintassi è la seguente

Type NomeTipoRecord = Record

Campo₁ : Tipo₁;

…

Campo_n : Tipo_n;

Case SelettoreVariante : TipoOrdinale of

ListaCostanti₁ : (Variante₁);

…

ListaCostanti_n : (Variante_n);

End;

Il SelettoreVariante è facoltativo; se si omette è necessario omettere anche i due punti successivi. Il SelettoreVariante deve essere di tipo ordinal.

Ogni ListaCostanti può essere composta da una costante dello stesso tipo di SelettoreVariante o da un elenco di costanti, sempre del tipo di SelettoreVariante, separate da virgole.

Ogni Variante è un elenco di dichiarazioni di con la stessa sintassi vista per la dichiarazione dei campi della parte principale del record.

Le parti variant dei record condividono lo stesso spazio di memoria. Si può   leggere o scrivere nei campi variant dei record in qualsiasi momento, tenendo conto che se si scrive in un campo di un variant e subito dopo si scrive in un campo di un altro variant, i dati possono essere sovrascritti. Se si specifica il un SelettoreVariante, questo funziona come un campo normale nella parte principale del record. Per un trattazione più approfondita si rimanda alla guida al linguaggio.

Tipi file

I tipi file rappresentano un insieme ordinato di elementi tutti dello stesso tipo. Un tipo file viene dichiarato come segue

Type NomeTipoFile = File of Tipo;

dove NomeTipofile è un nome di identificatore valido e Tipo un tipo di dato qualsiasi di dimensioni fissate. Non possono essere utilizzati quindi nelle dichiarazioni di tipi file puntatori, array dinamici, long string, altri file o qualsiasi altro tipo strutturato che contenga uno qualsiasi dei tipi precedentemente elencati.

Con riferimento all’esempio per i tipi record possiamo dichiarare un tipo file come segue

Type TFileElenco = File of TPersona;

…

Var FileElenco : TFileElenco;

Dichiarare un tipo od una variabile facendo uso solamente della parola file darà origine ad un tipo di file non tipizzato, senza tipo.