La Sintassi (parte seconda)

Operatori logici booleani

Segue un elenco degli operatori booleani definiti in Object Pascal:

Poco c'è da dire su questo tipo di operatori, essi seguono infatti le regole della
logica booleana.

Una considerazione importante va fatta sulle diverse modalità di valutazione che
l'Object Pascal offre. Questa è di default impostata sulla valutazione parziale, ma è
possibile impostare la valutazione totale utilizzando la direttiva del compilatore {$B+}
e disattivarla con la direttiva {$B-}. La valutazione parziale è da preferire
perché garantisce tempi di esecuzione più brevi, questo perché la valutazione
dell'espressione viene eseguita rigidamente da sinistra verso destra interrompendola nel
momento in cui la valutazione risulta completa. Questo tipo di valutazione si applica sia
all'operatore and che all'operatore or. In pratica quando viene valutata una
espressione del tipo X and Y e X assume valore False Y non viene valutata in
quanto il risultato dell'espressione è già noto; infatti una espressione del tipo X and
Y può risultare true in un solo caso, ovvero quando X ed Y sono true, in
tutti gli altri casi assume valore False.

Operatori logici con bit

Segue un elenco degli operatori logici applicabili ai bit definiti in Object Pascal:

Gli operatori shl e shr eseguono uno spostamento di bit, pari al numero
indicato dopo l'operando, rispettivamente a sinistra ed a destra. Per esempio, se X
contiene il valore 20 (in binario 010100) X shl 1 restituirà 40 (in binario
101000). Con riferimento all'esempio precedente, se al posto di shl ci avessimo shr
il risultato ottenuto sarebbe stato 10 (in binario 001010). Quindi quando si utilizza
l'operatore shl equivale a moltiplicare il primo operando per 2 elevato al secondo
operando. Seguendo sempre l'esempio precedente questo equivale a X * 2¹, mentre
nel caso dell'operatore shr l'equivalente operazione è quella di divisione del
primo operando per 2¹.

Operatori relazionali

Segue un elenco degli operatori relazionali definiti in Object Pascal:

Normalmente i tipi degli operandi devono essere compatibili, eccezion fatta per i tipi
real ed integer che possono essere confrontati tra di loro.

Per quanto riguarda le stringhe, vengono confrontate in base al set di caratteri ASCII
esteso. Il confronto viene effettuato da sinistra verso destra, carattere per carattere.
Ad esempio la stringa 'Delphi' è minore della stringa 'Pascal' in quanto la lettera 'D'
viene nel set di caratteri prima della lettera 'P'. Ovviamente qui la differenza tra le
due stringhe è immediata; se avessimo avuto una stringa 'Delphi' ed una stringa 'Delpho',
quest'ultima sarebbe stata maggiore della prima ma solamente grazie all'ultimo carattere
che costituisce la stringa. Nel caso di una stringa Str1 = 'Delphi' e di un'altra stringa
Str2 = 'Delphi', il confronto Str1 = Str2 restituirebbe true.

Alcuni degli operatori che abbiamo già visto possono essere applicati anche in
altri casi. Per esempio gli operatori +, -, *, <=, >=,
= , <> si applicano anche ai set (insiemi) con rispettivamente i
seguenti significati: unione, differenza, intersezione, sottoinsieme di, superset,
uguaglianza, disuguaglianza. Per i tipi set esiste anche un altro operatore, l'operatore in
che indica se un elemento è presente in un insieme. Per esempio, se disponiamo di un set
S composto dai seguenti elementi [1, 2, 3, 4] l'espressione 3 in S restituirà true
poiché 3 è un elemento del set S.

Per quanto riguarda i puntatori, gli operatori applicabili a quest'ultimi sono: +,
-, ^, =, <>. Il più importante (o il più usato) fra
questi, è l'operatore ^ che serve a dereferenziare un puntatore. Gli altri
operandi servono ad aggiungere uno scostamento all'indirizzo puntato, a calcolare lo
scostamento tra gli indirizzi puntati da due puntatori, a confrontare gli indirizzi
puntati da due puntatori.

Un altro operatore importante è @ che serve a restituire l'indirizzo di una
variabile, l'indirizzo di ingresso di una subroutine o di un metodo di classe.

Regole di precedenza degli operatori

Espressioni complesse vengono valutate seguendo delle regole per ciascuno degli
operatori visti. Di seguito è presente una lista degli operandi e dei rispettivi livelli
di precedenza.

In una espressione vengono valutati prima gli operatori con precedenza più alta. Per
esempio l'espressione

2 + 3 * 4 da come risultato 14 e non 20!

Infatti viene valutata prima la moltiplicazione tra 3 e 4 (12) poiché la
moltiplicazione ha una precedenza più alta ed in seguito viene aggiunto al risultato 2
(12 + 2 = 14).

Per modificare la precedenza degli operatori, si utilizzano le parentesi tonde '(',
')'. Racchiudendo tra parentesi tonde una espressione, questa verrà valutata per prima e
tutto il resto a seguire seguendo sempre le regole di precedenza.

Con riferimento all'esempio precedente, potremmo ottenere come risultato 20,
modificandolo come segue:

(2 + 3) * 4

Così facendo, verrà valutato prima il contenuto tra parentesi (2 + 3 = 5) ed il
risultato moltiplicato per 4 (5 * 4 = 20).

Le parentesi possono essere utilizzate anche quando la precedenza è già definita
dall'operatore, senza influenzare la valutazione, consentendo una maggiore leggibilità ed
interpretazione del codice. Sempre con riferimento all'esempio precedente scrivendo

2 + (3 * 4)

il risultato non cambierebbe, mettendo bene in evidenza quale parte dell'espressione
viene valutata prima.

Per gli operatori che godono della stessa precedenza, la valutazione avviene
normalmente da sinistra verso destra. Ad esempio

2 + 3 - 4 = 1

poiché 2 + 3 = 5 e 5 - 4 = 1.

Conversione di tipi

Un'altra funzionalità che ci mette a disposizione il Delphi, è la possibilità di
effettuare delle conversioni di tipo. Ciò è possibile racchiudendo tra parentesi tonde
l'espressione da convertire e facendo precedere il tutto (senza spazi) dal tipo in cui si
vuole convertire l'espressione. La sintassi esatta è la seguente

Ad esempio potrebbe essere utile convertire in boolean un valore intero
come 0 nel modo seguente: boolean(0).