MSX Turbo Pascal Rubrica a cura di Stefano Roperto

(parte 6)

Capitolo 6

PROCEDURE E FUNZIONI

Turbo Pascal, come abbiamo visto nel capitolo 4 fornisce al programmatore una completa collezione di procedure e funzioni che rendono il linguaggio moderno e completo. In questo capitolo vedremo le più importanti. Non è necessario spiegarle tutte in quanto molte sono comuni alle funzioni presenti in  altri linguaggi, compreso MSX basic, e altre sono di immediata comprensione. Il Turbo Pascal fornisce procedure e funzioni per:

• Manipolazione di stringhe
• Gestione dei files
• Allocazione di variabili, puntatori e gestione della memoria
• Input e output di dati

In aggiunta a ciò abbiamo a disposizione funzioni  e procedure di carattere generale.

Cominciamo con le funzioni aritmetiche :

Abs(num) dove num è un integer o un real del quale si chiede di restituire il valore assoluto che sarà dello stesso tipo di num

Arctan(num) restituisce l’angolo in radianti di cui la tangente è num. Num può essere real o integer, ma il risultato è sempre un real

Cos(num)  restituisce il coseno di num. Num è espresso in radianti e può essere real o integer. Il valore restituito è sempre un real

Exp(num)  restituisce l’esponenziale di num. Num può essere real o integer, ma il risultato è sempre un real

Frac(num)  restituisce la parte frazionaria di num. Num può essere real o integer, ma il risultato è sempre un real

Int(num)  restituisce la parte intera di num. Num può essere real o integer, ma il risultato è sempre un real

Ln(num) restituisce il logaritmo naturale di num. Num può essere real o integer, ma il risultato è sempre un real

Sin(num) restituisce il seno di num. Num è espresso in radianti è può essere real o integer, ma il risultato è sempre un real

Sqr(num) restituisce il quadrato di num Num può essere real o integer, ma il risultato è sempre un real

Sqrt(num) restituisce la radice quadrata di num Num può essere real o integer, ma il risultato è sempre un real

Per i tipi scalari abbiamo a disposizioni alcune Funzioni:

Pred(num) restituisce il predecessore di num in un a variabile di tipo scalare

Succ(num) restituisce il successore di num in un a variabile di tipo scalare

Odd(num) restituisce true se num è dispari e false se num è pari. Num deve essere un integer

Ci sono poi le cosiddette Funzioni di conversione:

Chr(num) restituisce il carattere il cui codice ascii è indicato da num

Ord(var) restituisce l’ordinale del valore var in un set definito dal tipo var. var può essere un qaulsiasi tipo scalare, eccetto real, e il risultato è di tipo integer

Round(num) restituisce il valore num arrotondato al valore intero più vicino. Num deve essere un real e viene restituito un integer

Trunc(num) restituisce l’intero maggiore (se num >=0) o il minore (se num >0). Num deve essere un real e viene restituito un integer

E infine le funzioni di uso generale generale:

Hi(num) restituisce il byte alto del valore intero num

KeyPressed(num) restituisce true se è premuto un taso o false se non è premuto alcun tasto

Lo(num) restituisce il byte basso del valore intero num

Random restituisce un numero casuale >= 0 <1

Random(num) restituisce un numero casuale >= 0 <num. Num deve essere un integer

ParamCount restituisce il numero integer di parametri passati al programma sulla linea di comando separati da spazio o tab

ParamStr(N) restituisce  l’eNessimo parametro dalla linea di comando e non può essere maggiore di ParamCount. ParamStr(0) restituisce il nome del programma

SizeOf(nome) restituisce un integer che indica il numero di bytes occupati in memoria dalla variabile o dal tipo name

Swap(num) scambia i byte di ordine alto e basso del valore integer num

UpCase(chr) restituisce l’equivalente maiuscolo del carattere chr. Se non esiste, non viene modificato nessun valore

Turbo Pascal fornisce un set completo di funzioni e  procedure dedicate alla gestione delle stringhe. Il tipo string e il tipo char sono compatibili tra loro , di fatto Le stringhe in Turbo Pascal sono un tipo di dato derivato dal tipo char, tecnicamente il tipo string è simile ad un array di caratteri come si evince dalla sua definizione in questo esempio, con la differenza che l’elemento di indice 0 contiene la lunghezza dell’array stesso:

type

              nome = string[50] ;{i caratteri vanno dall’elemento 1 all’elemento 50, mentre l’elemento 0 contiene il valore 50, per cui in memoria la stringa nome occuperà 51 bytes. Il limite della lunghezza di un a variabile stringa è pari a 255};

begin

…

…

nome:=’Mario Rossi’;

se utilizziamo l’istruzione Write passando come parametro la variabile nome

Writeln(nome);

il programma stamperà sullo schermo

Mario Rossi

E fin qui niente di nuovo. Da notare che il primo carattere della stringa nome è nome[1] ovvero “M” mentre nell’elemento 0 nome[0] è contenuto il valore della lunghezza della stringa, in questo caso nome[0]=11, infatti la stringa ‘Mario Rossi’ contiene 11 caratteri, e poi  nome[1]=’M’… nome[10]=’s’ nome[11]=’i’.  Naturalmente c’è molto di più le procedure e le funzioni dedicate alle stringhe facilitano la manipolazione dei dati in esse contenute:

Delete (str, pos, num)

Elimina dalla variabile str, a partire dalla posizione pos, num caratteri

Per esempio delete(‘ciao amici’,1,4) eliminerà 4 caratteri a partire dal primo, pertanto la stringa diventerà ‘ amici’)

Insert (testo, str, pos)

Inserisce il testo nella stringa str a partire dalla posizione pos

Per esempio Insert (‘cari ’,‘ciao amici’,5) la stringa ottenuta sarà ‘ciao cari amici’ infatti a partire dal quinto carattere, lo spazio tra le due parole, inserirà la stringa ‘cari ‘.

Str (num, stri)

Converte il parametro num in una stringa che viene memorizzata, nella variabile stri.

Val (stringa, valore, errcode)

Converte il numero contenuto in stringa nel valore numerico corrispondente al tipo indicato dalla variabile valore e pone in errcode un codice diverso da 0  se si verifica un errore

Copy (str, pos, n)

Ritorna n caratteri  della stringa str a partire alla posizione pos. Se n eccede la lunghezza della stringa viene restituita una stringa contenente solo i caratteri compresi nella stringa, se pos è oltre la lunghezza della stringa viene restituita una stringa nulla

Concat (stringa1, stringa2, stringa3, .. stringaN)

Restituisce una stringa formata dal concatenamento delle stringhe passate negli argomenti. Se la lunghezza eccede i 255 caratteri si verifica un errore. Concat si utilizza per compatibilità col pascal standard, ma al suo posto si può usare l’operatore di addizione:

writeln(concat(‘ABC’,’DEF’,’GHI’)); restituisce la stringa ‘ABCDEFGHI’ allo stesso modo di writeln(‘ABC’+’DEF’+’GHI’) che stampa ‘ABCDEFGHI’

Lenght (str)

Restituisce la lunghezza del parametro str

Pos ( stringaObj, stringaTarget)

Rerstuisce la posizione del primo carattere della stringaObj all’interno della stringaTarget. Se non viene trovata nessuna occorrenza viene restituito il valore 0

Dunque come abbiamo visto il Turbo Pascal deriva dal Pascal standard del quale amplia le possibilità tramite l’offerta di funzioni, procedure e tipi, come ha fatto Borland,  che possono essere facilmente implementati e riutilizzati in altri programmi da parte dell’utente. E vedremo in dettaglio più avanti con alcuni esempi una piccola parte di ciò che è possibile ottenere dalla natura di linguaggio strutturato tipica del Turbo Pascal. In questo capitolo abbiamo visto un po più nel dettaglio il tipo string, ma in Turbo Pascal è possibile utilizzare tipi di dati complessi come gli ARRAY, i RECORD e i SET. Come abbiamo visto il tipo string è simile ad un array di caratteri che ha nell’elemento di indice zero il valore che indica la lunghezza della stringa. Ora vedremo come si definisce un array. Intanto diciamo che un array è una collezione di oggetti dello stesso tipo: possiamo definire array di interi, di caratteri, di stringhe, di numeri reali, ma non possiamo definire un array che contenga dati di tipi diversi tra loro. Per esempio

type

giorni = (Lun,Mar,Mer,Gio,Ven,Sab,Dom)

var

OreLavoro :array[l .. 8] of Integer;

Settimana:  array[l .. 7] of giorni;

Si possono inoltre definire array a più dimensioni ad esempio

Type

OreLavoro =array[l .. 8] of Integer;

Settimana=  array[l .. 7] of Orelavoro;

Var

settimanaLavorativa: settimana;

dove abbiamo a disposizione una matrice di 7 x 8 variabili.

Vediamo ora un semplice programma di esempio così da chiarire meglio:

program Matrici;

{questa che segue è una direttiva al compilatore. indica al compilatore di eseguire sempre un controllo sulla validità degli indici. il controllo}

{rende più lenta l’esecuzione del programma, per cui è bene attivarlo in fase di debug ($R+) e disattivarlo quando si rilascia il programma ($R-)}

{$R+}

Type

OreLavoro =array[1..8] of Integer;

Settimana=  array[1..7] of Orelavoro;

lettere = string[20];

Var

settimanaLavorativa: Settimana; ;{ questo è un array a 2 dimensioni [1..7,1..8}

arraysemplice : array[0..100] of real;{ questo è un array di real}

{il seguente è un array di tipo stringa.}

{Non è possibile dichiarare direttamente un array di tipo stringa}

{con un’istruzione tipo “parole:array[0..20] of string[50]”}

{ma è necessario definire prima un tipo stringa come” lettere = string[20];”}

parole: array[0..20] of lettere;

x,y,k : integer;

{riempiamo l’array a due dimensioni con i numeri da 1 a n}

begin

k:=1;

for x:=1 to 7  do

for y:=1 to 8  do

begin

settimanaLavorativa[x,y]:=k;

k:=k+1;

end;

for x:=1 to 7 do

begin

for y:=1 to 8 do

write(settimanalavorativa[x,y],’  ‘);

writeln;

end;

{assegnamo un valore ad un array di real}

arraysemplice[5]:=34.56;

{assegnamo una stringa ad un array di srting}

parole[0]:=’buongiorno’

end.

Come si vede le possibilità sono diverse ed è facile immaginare come sia possibile definire array a partire da tipi definiti dall’utente, in maniera semplice ed efficace. Dicevamo che un array è una collezione finita di oggetti dello stesso tipo, dunque come possiamo mettere insieme oggetti di tipo diverso? Il Turbo Pascal mette a disposizione il tipo Record che rappresenta un tipo di dato strutturato che ci consente di tenere insieme dati di tipo diverso: numeri, caratteri, stringhe, valori booleani, tipi definiti dall’utente, persino altri record. Nel MSX Basic l’istruzione field si avvicina al concetto di record, ma rispetto al tipo record del Turbo Pascal è molto limitata. Vediamo un primo esempio di record

Nella sezione Type si definisce il record

type

anagrafica = Record

Nome: string[40];

Cognome: string[40];

Indirizzo1:  string[40];

Citta:  string[40];

Cap:  string[5];

età: integer;

Peso: real;

Altezza:real;

end;

{e nella sezione var si definiscono le variabili del tipo definito record}

var

agenda : anagrafica;

begin

agenda.Nome:=’Mario’

agenda.Cognome:=”Rossi’

end.

Il Turbo Pascal mette a disposizione la parola chiave With che permette di semplificare la gestione dei record omettendo il nome della variabile facendo riferimento solo ai campi, in questo modo:

with agenda do

begin

Nome:=’Mario’;

Cognome:=’Rossi’;

….

Peso:=77,4

Altezza:=1.78

End;

allo stesso modo è possibile dichiarare un array di record aggiungendo la parola chiave alla dichiarazione della variabile. In questo caso sia che si utilizzi la notazione diretta o la notazione with bisogna indicare l’elemento dell’array:

agenda[x].Nome:=’Nome’

o tramite la parola chiave with,

with agenda[x]do

begin

Nome:=’Mario’;

Cognome:=’Rossi’;

….

Peso:=77,4

Altezza:=1.78

End;

Vediamo ora il tipo SET: Un set o, come si usa dire in matematica, un insieme è una collezione di oggetti correlati tra loro che possono essere pensati come un intero. Ogni oggetto in un insieme di questo tipo è chiamato membro o elemento dell’insieme. Esempi di insiemi potrebbero essere:

tutti i numeri interi da 1 a 100

tutte le lettere dell’alfabeto

tutti i numeri primi

due inisemi sono uguali tra loro solo se tutti gli elementi dei due insiemi sono uguali. Ci sono tre operazioni che possono essere effettuate sugli insiemi:

l’unione, l’intersezione e il complemento relativo:

L’unione  di due insiemi, per esempio A=[1,2,3] e B=[2,8,5] , restituisce un insieme che comprende i membri di entrambi gli insiemi: A+B=[1,2,3,5,8]

L’intersezione di due insiemi per esempio A=[1,2,3] e B=[2,8,5], restituisce un insieme che comprende solo i membri presenti in entrambi gli insiemi: A*B=[2]

Il complemento relativo di B rispetto ad A per esempio A=[1,2,3] e B=[2,8,5], resrtuisce un insieme i cui membri appartengono ad A, ma non a B: A-B=[1,3]

Sebbene in matematica non vi sono restrizioni nei tipi di oggetti che possono essere contenuti in un insieme, Turbo Pascal offre una forma ristretta di Set, ovvero è un SET può contenere solo oggetti dello stesso tipo, chiamato tipo base, e il tipo base deve essere un tipo di dato semplice eccetto il tipo real. Un esmpio di dichiarazione di SET è il seguente:

type

GiorniDellaSettimana set of (Lun,Mar,Mer,Gio,Ven,Sab, Dom);

Caratteri Set of char;

gli operatori che consentono di operare sugli insiemi sono i seguenti:

+            produce l’unione di due insiemi

–             produce il complemento relativo di due insiemi

*            produce l’intersezione di due insiemi

=            controlla l’uguaglianza tra due insiemi

<>         controlla l’inuguaglianza tra due insiemi

>=         controlla se tutti i membri del secondo insieme sono inclusi nel primo

<=         controlla se tutti i membri del primo insieme sono inclusi nel secondo

In          controlla se un elemento è presente nell’insieme indicato nell’operazione: se a=9 e b=set of integer allora l’espressione

If (a in b)  then… risulta vera

Ora disponiamo di sufficienti informazioni per cominciare a scrivere qualche programma in Turbo Pascal . Nel prossimo capitolo daremo un’occhiata ai file, in modo che possiamo disporre anche della possibilità di salvare e caricare i dati dei nostri programmi e successivamente concluderemo con la creazione e l’utilizzo delle librerie nei nostri programmi in Turbo Pascal