Differenze tra le versioni di "Pascal"

34 968 byte rimossi ,  15 anni fa
nessun oggetto della modifica
== Sommario ==
 
#[[/Introduzione/]]
#[[/Le variabili/]]
#[[/Commenti/]]
#[[/Input e Output/|I/O]]
#[[/Librerie e Funzioni/|Librerie e funzioni]]
#[[/Istruzioni di controlloFunzioni/]]
#[[/Tipi di dati/]]
#[[/Array/]]
#[[/Strumenti/|Strumenti utili]]
 
= Le variabili =
 
Un programma come quello appena fatto può essere divertente e interessante, ma offre ben poche possibilità di sviluppo. Quasi tutti i tipi di programmi richiedono l'uso di calcoli e di “cose da ricordare”. Per questo motivo è necessario introdurre il concetto di variabile. Una variabile, può essere paragonata ad una casella di una certa dimensione nella quale si possono inserire e/o leggere dati mentre il programma è in esecuzione. In pratica le variabili sono delle etichette che noi diamo ad un'area di memoria, che verra usata per depositare dei dati. La quantita di memoria riservata dipende dal tipo di variabile che andiamo a dichiarare, e dal particolare compilatore che usiamo. Il compilatore pascal ha la necessita di conoscere l'uso e lo scopo di tutte le etichette che incontra durante la fase di compilazione, è indispensabile quindi dichiarare esplicitamente, in particolari punti del programma, le variabili e altre ''cose'' che vedremo. L'area di dichiarazione delle variabili inizia con la parola chiave ''var''.<br />
Il concetto risulta abbastanza chiaro con un esempio pratico.
 
program VariabiliVarie;
var
n:integer;
r:real;
begin
n:=3;
r:=sqrt(n);
n:=5;
writeln(n);
writeln(r);
end.
 
Il programma in sè è estremamente sciocco, ma ci permette di osservare come le variabili vengano utilizzate in Pascal. Analizzamo come al solito le singole righe.
* La prima riga è, come prima, la dichiarazione che si sta facendo un programma e non altro (più tardi si vedrà cosa altro si può fare);alla parola riservata ''program'' segue il nome scelto per il programma.
* Nella seconda e nella terza riga vengono dichiarate le variabili. La dichiarazione ha sempre la forma
''var''
nomevariabile : ''tipo'';
nuovavriabile : ''tipo'';
Come dicevamo il Pascal non permette di dichiarare durante il programma variabili aggiuntive, perciò è necessaria una buona progettazione teorica del programma per non trovarsi a dover correggere molti errori in corso di compilazione.
 
=== Altri concetti di sintassi===
Abbiamo visto due esempi. Possiamo notare che entrambi riflettono anche uno stile di scrittura del codice, che diciamo ''stile di formattazione''. Notiamo che il codice presenta varie rientranze. Queste hanno lo scopo di rendere più semplice la vita del programmatore. Consentono di individuare a colpo d'occhio un blocco, semplicemente osservando l'andamento delle rientranze. Per il compilatore tutto ciò è ininfluente, inquanto lui individua i blocchi tramite le parole chiavi e le istruzioni le trova separate da un carattere apposito.<br />
Se provate a compilare le seguenti righe otterrete lo stesso programma visto nell'esempio precedente. Per il compilatore non ci sono differenze, mentre per il programmatore che dovrà estendere o correggere questo codice le cose si complicano.
 
program VariabiliVarie; var n:integer; r:real; begin
n:=3; r:=sqrt(n); n:=5; writeln(n); writeln(r); end.
 
 
Ma quali sono i tipi di variabile utilizzabili?
 
== Integer ==
Il tipo più utilizzato è in genere il tipo ''integer''. Corrisponde agli interi, anche se non proprio a tutti;comprende gli interi da -32768 a 32767,e occupa una memoria di 16 bit(2 byte). Essendo il computer una macchina limitata, non è possibile fare somme fino all'infinito.Infatti con alcuni semplici programmi si può osservare che esiste un limite superiore per gli interi (come nel caso del tipo ''integer'',cioè 32767), oltre al quale si ricade nel limite inferiore, come se fosse una circonferenza.Il fenomeno dello sforamento del limite massimo è detto Overflow.
 
Ogni tipo di dato ha delle operazioni permesse. In questo caso le operazioni che danno come risultato un integer sono:
* ''+'' permette di sommare due valori di tipo integer.
* ''-'' permette di calcolare la differenza fra due valori integer.
* ''*'' permette di moltiplicare due valori, ottenendo sempre un integer.
* ''div'' permtte di calcolare la parte intera del rapporto fra due interi.
* ''mod'' permette di calcolare il resto della divisione fra due interi.
 
Le funzioni matematiche che danno come risultato un intero sono, invece
* ''abs(n)'' che calcola il valore assoluto del numero intero ''n''
* ''round(n)'' che arrotonda qualunque numero all'intero più vicino ad ''n''
* ''trunc(n)'' che tronca il numero all'intero minore di ''n''
* ''sqr(n)'' ne calcola infine il quadrato.
 
Proviamo a fare un programma che utilizzi alcune operazioni. Per ora ci limiteremo a fare semplici assegnamenti di variabili all'interno del programma stesso. Presto troveremo il modo di dinamicizzare le cose...
 
program Pari;
var n:integer;
begin
n:=5;
if (n mod 2 = 0) then write (“pari”)
else write (“dispari”);
end.
 
Il programma presenta alcuni costrutti che non abbiamo ancora visto, ma la cui intepretazione è semplice. Analizziamo come al solito riga per riga.
* Come al solito la prima riga contiene la dichiarazione del titolo.
* Dichiarazione di una sola variabile ''n'' di tipo intero.
* Inizia il programma.
* Assegnamo a ''n'' il valore 5.
* Inizia un costrutto condizionale. Letto “alla lettera” significa “se il resto della divisione fra n e 2 è uguale a zero, allora scrivi ''pari'' altrimenti scrivi ''dispari''”. Da notare, lo rivedremo e faremo alcune considerazioni, che prima di ''else'' non va '''mai''' messo il “;”.
 
== Char ==
Frequentemente si utilizzano invece degli ''integer'' i ''char'', per rappresentare numeri interi piccoli. Infatti i char rappresentano il range di numeri interi che va da 0 a 255 - corrispondente ai codici [[w:ASCII|ASCII]] - e permettono la visualizzazione nei due formati: intero, ascii. Le operazioni possibili sono le stesse degli integer, ma ci sono due funzioni in più che permettono la trasformazione da intero a carattere e viceversa. Queste funzioni sono
* ''chr(x)'' che permette di trasformare l'intero ''x'' nel corrispondente carattere
* ''ord(x)'' che permette di trasformare il carattere ''x'' nel corrispondente intero ASCII
 
Un semplice esempio di uso potrebbe essere la stampa della tabella dei codici ascii.
 
program ASCII;
var n:integer;
begin
for n:=0 to 255 do
writeln(n, ' ==> ', chr(n));
end.
 
Come al solito analizziamo riga per riga.
* Dichiarazione del programma,
* Definizione della variabile ''n'' come char
* Inizio del programma
* Il costrutto ''for...to...do'' non l'abbiamo ancora visto, ma facendo come prima la traduzione letterale, possiamo intuirne il significato: ''Per n che va da 0 a 255 fai...'' Questo tipo di costrutto, detto ''ciclo'', verrà comunque affrontato in seguito.
* scriviamo su schermo il numero ''n'' seguito dai caratteri ''==>'' e poi dal corrispondente carattere ASCII.
 
== Real ==
Le variabili di tipo real corrispondono ai numeri reali, ovvero i numeri con la virgola. Anche qui, come per gli integer, dobbiamo dare delle limitazioni. Essendo, come già sottolineato un computer una macchina limitata e discreta, inevitabilmente non può superare una certa precisione nel calcolo con i numeri reali. Per questo motivo spesso nelle strutture condizionate si devono cercare di utilizzare stratagemmi per evitare problemi.
 
Le operazioni di base possibili sembrano meno di quelle possibili con char e integer, ma attraverso l'utilizzo della libreria matematica aumentano in modo incredibile. Comunque le operazioni basilari sono:
* ''+'' permette di sommare due valori di tipo real.
* ''-'' permette di calcolare la differenza fra due valori real.
* ''*'' permette di moltiplicare due valori, ottenendo sempre un real.
* ''/'' permette di calcolare il rapporto fra due reali.
 
== Boolean ==
L'algebra booleana è fondamentale nell'informatica. Questa permette infatti di fare calcoli sulla veridicità o falsità di una affermazione. Le variabili booleane infatti possono assumere solo i valori logici vero (''true'') e falso (''false''). Le operazioni possibili sono diverse da quelle possibili per gli altri tipi di variabile:
* ''and'' che corrisponde al simbolo matematico <math>{}\wedge{}</math> e al concetto di ''e contemporaneamente''
* ''or'' che rappresenta <math>{}\vee{}</math> e ''oppure''
* ''not'' operatore che corrisponde alla negazione
* ''xor'' che corrisponde matematicamente all'''aut'', ovvero <math>{}\dot{\vee}{}</math>
 
Le variabili di tipo booleano si dichiarano con la parola riservata ''boolean''.
var
variabile_booleana:boolean;
 
Si inizializzano così:
variabile_booleana:=true;
oppure
variabile_booleana:=false;
 
L'utilizzo di variabili Boolean è in genere limitato all'analisi di particolari aspetti dell'input da utente, o all'utilizzo come 'flag' nella programmazione più avanzata.
 
== String ==
Le variabili string sono variabili che possono contenere una stringa alfanumerica di caratteri.
 
La dichiarazione di una variabile string ha sintassi:
 
nome_della_variabile : string[n];
 
Ovvero afferma che la variabile ''nome_della_variabile'' può contenere una riga di massimo ''n'' caratteri.
 
== Tabella: Operazioni ed operatori ==
<center>
<table border="1" width="50%" cellpadding="2" cellspacing="0">
<tr><th>Operatore </th><th>Operandi</th><th>Risultato</th></tr>
<tr><td align="center">+</td><td>real o integer o char</td><td>real o integer o char</td></tr>
<tr><td>-</td> <td>real o integer o char</td> <td>real o integer o char</td></tr>
<tr><td>*</td> <td>real o integer o char</td> <td>real o integer o char</td></tr>
<tr><td>/</td> <td>real o integer o char</td> <td>real</td></tr>
<tr><td>mod</td> <td>integer o char</td> <td>integer</td></tr>
<tr><td>div</td> <td>integer o char</td> <td>integer</td></tr>
<tr><td>sqr</td> <td>real o integer o char</td> <td>integer</td>
<tr><td>sqrt</td> <td>real o integer o char</td> <td>real</td></tr>
<tr><td>abs</td> <td>real o integer o char</td> <td>real o integer o char</td></tr>
<tr><td>trunc</td> <td>real o integer o char</td> <td>integer</td></tr>
</table>
</center>
Il significato di questi operatori è stato mostrato in uno dei paragrafi precedenti,ad eccezione di ''sqrt'',che calcola la radice quadrata;la sintassi per ''sqrt'' è ''sqrt(n)'',dove ''n'' è una variabile di tipo real,integer,o char.
 
=Commenti=
 
In programmazione,il commento è una parte di testo che non viene eseguita nel programma,ma che serve a chi scrive il codice per lasciare qualche appunto,specie se quel codice deve essere letto da altri.
 
In pascal,i commenti si mettono tra parentesi graffe(digitabili tramite Shift+Alt Gr+tasto delle parentesi quadre),o tramite parentesi tonde,con il testo introdotto e terminato da un asterico;
Ad esempio:
 
{Questo è un commento}
oppure
(*Questo è un commento*)
 
= Input e Output =
Finalmente ci occupiamo del grande problema dell'input-output. Gran parte delle funzioni di input-output sono contenute nella libreria standard di pascal. Queste funzioni sono tipicamente
*''write()'' e ''writeln()'' che permettono, come già visto in precedenza, di stampare su schermo il contenuto delle parentesi.
*''read()'' e ''readln()'' che permettono di leggere l'input dell'utente da tastiera inserendo fra le parentesi il nome della variabile in cui vogliamo salvare il dato.
La differenza fra la versione con e senza ''ln'' è che la prima va a capo prima della scrittura o dell'immissione, la seconda versione no.
 
Un semplice esempio basato sull'uso delle variabili e dell'input-output potrebbe essere un modo per personalizzare un programma, salvando in una stringa il nome dell'utente per inserirlo nelle domande.
 
program username;
var name: String[50];
uses crt;
begin
clrscr;
writeln('Inserisci il nome');
readln(name);
clrscr;
writeln('Benvenuto, ', name);
readkey;
end.
 
Analizziamo come al solito riga per riga.
* Dichiarazione del nome
* Dichiarazione della variabile ''name'' di tipo Stringa di dimensione 50
* Dichiarazione delle librerie necessarie. Di questo argomento riparleremo a breve, ma sappiate che almeno due dei comandi utilizzati di seguito sono dipendenti da questa libreria.
* Inizio programma
* Pulizia dello schermo. Questa è la prima (e forse la più usata) delle due funzioni che dipendono da ''crt''.
* Scrittura della stringa ‘Inserisci il nome’
* Lettura della stringa corrispondente al nome ed inserimento di questa stringa letta da tastiera nella variabile ''name''
* nuova pulizia dello schermo
* Scrittura del messaggio di benvenuto.
* Nuova funzione dipendente dalla libreria ''crt'' che permette di leggere un solo carattere qualunque da tastiera. Vedremo che questa funzione e molto utilizzata per risolvere un problema riguardo all'esecuzione dei programmi compilati finora.
 
Il contenuto della parentesi del ''writeln'' può essere sia un testo che una variabile.
La parte testuale è compresa tra due apici;per separare il testo dalle variabili si usa una virgola,come nell'esempio precedente.
Quando la variabile inserita nel ''writeln'' è di tipo real,si deve specificare con quante cifre dev'essere rappresentato il numero,e quante di queste devono essere decimali;per questo,si utilizza la sintassi
nome_della_variabile : numero_di_cifre : numero_di_cifre_decimali;
Ad esempio:
writeln(n:8:6);
 
Ovvero,il contenuto della variabile ''n'' verrà rappresentato con 8 cifre,di cui 6 decimali.
 
Riguardo Input e Output,si può anche fare un esempio con i numeri,con un programma che calcoli la radice quadrata di un numero intero:
 
program quadrato_di_un_numero;
var n:integer;
r:real;
uses crt;
begin
clrscr;
writeln('Inserisci un numero reale');
readln(n);
clrscr;
r:=sqr(n);
writeln('Il quadrato del numero inserito è',r:10:6');
readkey;
end.
 
*Il programma la stringa 'Inserisci un numero reale';
*Con ''readln(n)'' assegna alla variabile n un valore immesso da tastiera;
*Alla variabile ''r'' viene assegnato il valore del quadrato di ''n'';
*Viene scritto il risultato.
 
Si nota che per l'assegnazione di un certo valore a una variabile si usa la sintassi:
nome_della_variabile := valore_assegnato_alla_variabile;
 
Questo valore può essere,come nell'esempio precedente,il risultato di un'operazione.
 
= Librerie =
 
Una libreria non è altro che un file contenete molte funzioni e variabili che possono essere utilizzate una volta incluso il file all'interno del programma. Questo da un punto di vista teorico è molto utile perché permette di avere programmi molto brevi, ma da un punto di vista di sviluppo è piuttosto negativo, poiché una volta compilati anche programmi molto semplici possono essere estremamente “grandi” in dimensioni fisiche (ovvero in kByte).
 
Il Pascal utilizza come libreria standard ''Turbo.tpl''. Questa contiene tutte le funzioni di base. Non viene mai invocata, perché lo fa in automatico il compilatore alla compilazione. Ma come abbiamo già visto esistono molte altre librerie.
 
Dall'ultimo programma osservato si nota come deve essere fatta la dichiarazione delle librerie:
uses ''nomelibreria, nomelibreria, ...'';
''uses'' è una parola riservata, quindi non può essere usata come nome di variabile o funzione.
 
==crt==
La libreria di gran lunga più usata è sicuramente ''crt'', con tutte le funzioni relative all'estetica in ambito DOS. Ma non abbiamo ancora affrontato il problema dell'utilizzo di librerie all'interno dei nostri programmi.
 
Probabilmente avrete notato che eseguendo i programmi fatti finora l'esecuzione terminava istantaneamente, non appena il risultato veniva mostrato sullo schermo. Questo può essere abbastanza scomodo. Ma anche per questi problemi aiuta la libreria CRT, con la funzione ''readkey();'' che, come abbiamo già visto, permette di leggere il primo carattere che viene immesso da tastiera.
 
===funzioni di crt===
 
'''clrscr;'''
Questa funzione permette di pulire lo schermo e di posizionare il cursore in alto a sinistra in posizione (1,1)
 
'''cursoroff; '''
'''cursoron;'''
Queste due funzioni permettono di spegnere o accendere il cursore.
 
'''gotoXY(''posX'', ''posY'');'''
Questa procedura permette di posizionare il cursore in una posizione precisa sullo schermo.
 
'''sound(''hz'');'''
'''nosound;'''
La funzione ''sound'' fa emettere alla macchina un suono alla frequenza ''hz''. Per fermare questo suono bisogna assolutamente utilizzare la procedura ''nosound''
 
'''delay(''time'');'''
Questa funzione fa sì che il sistema si fermi in pausa per un certo numero di millisecondi definito da ''time''. L'uso della procedura <nowiki><pre>delay</pre></nowiki> è tipicamente usata quando si fa uso di suoni. La struttura d'uso generalmente è la seguente:
sound(440);
delay(1000);
nosound;
Il risultato è un LA di durata un secondo.
La funzione delay() è però basata sul clock del processore per calcolare il tempo, quando è stato creato il Pascal ovviamente i processori non avevano la potenza di oggi. La funzione delay() è quindi difficile da controllare ma se si vogliono ottenere ritardi definiti con bassa precisione cronometrica si possono inserire più delay() di seguito o sfruttare i cicli.
 
'''textcolor(''numero'');'''
'''textbackground(''numero'');'''
 
Permettono di cambiare colore al testo e allo sfondo rispettivamente. Il codice di colore può anche essere il nome in inglese del colore. Questo perché nella libreria crt sono definite anche alcune costanti fra cui proprio quelle relative ai colori. Fra l'altro si può utilizzare anche la costante blink, per creare testo intermittente. Questo uso deve essere fatto così:
...
textcolor(white+blink);
textbackground(blue);
...
 
 
Tuttavia,se per compilare il programma si usa Turbo Pascal,se si usa la unit ''crt'' quando viene compilato il programma,potrebbe comparire l'errore ''Runtime Error 200:divide by 0'' pur senza che vi sia alcuna divisione per 0 all'interno del programma.Questo è dovuto a un problema d'incompatibilità,che non si verifica però se si usa un altro compilatore.
 
Comunque,per far sì che la finestra del programma non si chiuda non appena si sia completato,non dando l'opportunità di vedere i risultati,si può mettere ''readln'' alla fine dell'algoritmo,prima dell'''end''.In questo modo,la schermata resta,e la finestra del programma si chiude quando si preme ''Invio''.
 
==== Tabella: Le frequenze delle note====
<center>
<table border="1" width="50%" cellpadding="2" cellspacing="0">
<tr><th>Nota </th><th>Frequenza</th><th>Formula</th></tr>
<tr><td align="center" valign="center">Do</td><td valign="center">262</td><td><math>440 \cdot (2^\frac{1}{12})^{-9}</math></td></tr>
<tr><td align="center" valign="center">Do#/Reb</td><td valign="center">277</td><td><math>440 \cdot (2^\frac{1}{12})^{-8}</math></td></tr>
<tr><td align="center" valign="center">Re</td><td valign="center">294</td><td><math>440 \cdot (2^\frac{1}{12})^{-7}</math></td></tr>
<tr><td align="center" valign="center">Re#/Mib</td><td valign="center">311</td><td><math>440 \cdot (2^\frac{1}{12})^{-6}</math></td></tr>
<tr><td align="center" valign="center">Mi</td><td valign="center">330</td><td><math>440 \cdot (2^\frac{1}{12})^{-5}</math></td></tr>
<tr><td align="center" valign="center">Fa</td><td valign="center">349</td><td><math>440 \cdot (2^\frac{1}{12})^{-4}</math></td></tr>
<tr><td align="center" valign="center">Fa#/Solb</td><td valign="center">370</td><td><math>440 \cdot (2^\frac{1}{12})^{-3}</math></td></tr>
<tr><td align="center" valign="center">Sol</td><td valign="center">392</td><td><math>440 \cdot (2^\frac{1}{12})^{-2}</math></td></tr>
<tr><td align="center" valign="center">Sol#/Lab</td><td valign="center">415</td><td><math>440 \cdot (2^\frac{1}{12})^{-1}</math></td></tr>
<tr><td align="center" valign="center">La</td><td valign="center">'''440'''</td><td><math>440 \cdot (2^\frac{1}{12})^0</math></td></tr>
<tr><td align="center" valign="center">La#/Sib</td><td valign="center">466</td><td><math>440 \cdot (2^\frac{1}{12})^1</math></td></tr>
<tr><td align="center" valign="center">Si</td><td valign="center">494</td><td><math>440 \cdot (2^\frac{1}{12})^2</math></td></tr>
</table>
</center>
La frequenza di riferimento è quella del La, ovvero 440 Hz. Per ottenere le altre ottave basta raddoppiare o dimezzare le frequenze della nota corrispondente di questa ottava centrale.
 
==math==
===funzioni di math===
 
==graph3==
Un altra libreria molto usata è ''graph3'' che permette l'utilizzo della grafica, e tramite semplici comandi si riesce a disegnare facilmente punti, linee, e altre forme geometriche.
L'utilizzo di questa libreria sostituisce alcune funzioni della libreria ''crt'' come il ''clrscr'' che viene sotituito da ''clearscreen'', dal momento in cui si entra nella modalità grafica con il comado ''graphcolormode'' la grandezza dei caratteri aumenta e la risoluzione diminuisce.
===funzioni di graph3===
 
'''plot(x,y,c)'''
questa funzione permette di disegnare un punto di coordinate x;y di colore c che può variare tra 0-1-2-3;
'''draw(x1,y1,x2,y2,c)'''
questa funzione permette di disegnare una linea dal punto x1;y1 al punto x2;y2 di colore c;
 
= Strutture condizionate =
 
==If,then,else==
 
In qualcuno degli esempi precedenti si è vista la sintassi con ''if'',''then'' e ''else'';vediamo in cosa consiste;
Nella pratica,questo costrutto consente la scelta fra due alternative:'''se'''(if) c'è una certa condizione '''allora'''(''then'') il programma esegue una certa istruzione;'''altrimenti'''(''else'') esegue un'altra istruzione:
 
'''if''' condizione '''then''' istruzione
'''else''' istruzione;
 
che come abbiamo già visto permette la scelta fra un caso vero e un caso falso e in base a questo esegue il contenuto del ''then'' o dell'''else''. Spesso il ramo in else non serve.
 
Più precisamente,quando le istruzione che seguono il ''then'' sono più di una,esse devono essere comprese tra ''begin'' e ''end'';ciò vale anche per le istruzioni che seguono l'''else''
'''if''' condizione '''then'''
''begin''
istruzione 1;
istruzione 2;
...
istruzione n
''end''
'''else'''
''begin''
istruzione 1;
istruzione 2;
...
istruzione n
''end'';
 
Si nota come a l'''end'' che segue le istruzioni dopo il ''then'' non segue un punto e virgola;e che all'istruzione prima di ''end'' non è obbligatorio che sia seguito un punto e virgola.
 
Facciamo un esempio pratico:si vuole calcolare la radice quadrata di un numero;ma se il numero dovesse essere negativo,la radice quadrata non può essere espressa con i numeri reali.
Il programma deve perciò:
*Acquisire il numero
*''Se'' il numero è positivo,''allora'' ne calcola la radice quadrata e espone il risultato;''altrimenti'' scrive un messaggio;
 
program radice_quadrata;
var n,r:real;
begin
writeln('Inserisci un numero positivo');
readln(n);
if n>=0 then
begin
r:=sqrt(n);
writeln('La radice quadrata del numero inserito è',r:8:3);
end;
else writeln('La radice di un numero negativo non può essere espressa con numeri reali');
readln;
end.
 
==Case...of,else==
 
Questo metodo permette di fare scelte più complesse;la sintassi è
'''case''' selettore '''of'''
''valore 1'' : begin
istruzioni;
end;
''valore 2'' : begin
istruzioni;
end;
...
''valore n'' : begin
istruzioni
end;
'''else''': begin
istruzioni;
end;
end;
 
Con il costrutto case, il valore della variabile selettore viene confrontato con il valore di ogni singolo caso, quando viene trovato un caso che eguaglia il selettore l'istruzione che segue viene eseguita; poi il controllo passa alla prima istruzione dopo il costrutto ''case''.
Se nessun caso soddisfa il selettore, viene eseguita l'ultima istruzione, quella individuata dalla parola '''else'''.Se la parte con ''else'' viene omessa e il selettore non è compreso tra nessuno dei casi in elenco,si passa anche in questo caso alla prima istruzione dopo il contrutto ''case''.Quando c'è solo un istruzione che segue un certo caso,si può omettere ''begin'' e ''end''. Occorre fare attenzione che il costrutto ''case'' termina con un ''end''.
 
Facciamo un esempio del costrutto case:
'''case''' Contatore '''of'''
1, 2, 50, 210: writeln(contatore);
30, 60..80 : begin
writeln(variabile);
end;
'''end;'''
alcune considerazioni sull'esempio proposto:
*abbiamo omesso la parte facoltativa '''else'''
*sono state scritte delle liste di possibili casi
*è stato usato un range di valori x..y;al terzo rigo,''60..80'' sta a indicare tutti i valori compresi o uguali tra 60 e 80.
 
=Strutture Iterative =
In Pascal abbiamo diversi tipi di struttura iterative (in genere vengono detti "''cicli''"):
 
 
==For ==
 
 
Questa struttura, ci permette di ripetere una determinata serie di istruzioni per un numero finito di volte. La sua sintassi è:
 
'''for''' Contatore:=valore_iniziale '''to''' valore_finale '''do'''
begin
istruzione 1;
istruzione 2;
...
istruzione n;
end;
 
 
Nella pratica questo costrutto consente la ripetizione di un certo gruppo di istruzioni fino a quando la variabile contatore raggiunge un certo valore: '''per'''(for) contatore:=valore_iniziale '''fino a'''(to) valore_finale '''fai'''(do) un gruppo d'istruzioni.
Per Contatore s'intende una variabile (di solito vengono usate le lettere I,L,M,N,J,K),che da un valore iniziale cresce di un certo valore ogni ciclo d'istruzioni;fino a che non raggiunge il valore_finale,che rappresenta il valore per il quale il ciclo terminerà.
 
L'iterazione può anche procedere in modo che la variabile contatore decresca a ogni ciclo;in questo caso la sintassi è:
'''for''' contatore:=valore_iniziale '''downto''' valore_finale '''do'''
begin
istruzione 1;
istruzione 2;
...
istruzione n;
end;
 
Facciamo un esempio:scrivamo un programma che calcoli la somma dei primi n numeri naturali.
Il programma deve:
*Leggere n;
*Con un ciclo for,sommare tutti i numeri da 1 a n;
*Esporre il risultato.
 
program sommatoria;
var i,n,s:integer;
begin
s:=0;
writeln('Inserisci n');
readln(n);
for i:=1 to n do
begin
s:=s+i;
end;
writeln('La somma dei primi n è',s);
readln;
end.
 
Vediamo il programma riga per riga:
*Dichiarazione del programma;
*Dichiarazione delle variabili:i è la variabile contatore,n fa da valore finale del ciclo for,q è di volta in volta il quadrato di i,s è la somma dei quadrati dei numeri fino a n.
*Inizio del programma
*La somma è inizialmente uguale a 0;
*Messaggio di testo;
*Il programma legge n;
*Il ciclo for:''per i uguale a 1 fino a che i non sia uguale a n,esegue il gruppo d'istruzioni:''
*Inizio del ciclo;
*Alla variabile s viene assegnata la somma del valore di s+i;prima del ciclo s era uguale a 0;
quindi s:=1;
*Fine del ciclo;se i è diverso da n,il ciclo viene riavviato,altrimenti,si prosegue all'istruzione successiva.Automaticamente,alla fine del ciclo,i viene incrementato di 1.
 
Vediamo cosa sarebbe successo se n fosse stato,ad esempio,50:
*i:=2,diverso da 50,quindi il ciclo continua;
*s:=s+i,cioè s:=1+2;infatti la variabile s aveva valore 1,alla fine della prima fase del ciclo.
*Reinizia il ciclo;i:=3,diverso da 50,quindi il ciclo continua;
*s:=s+1;cioè s:=3+3;
*E così via,fino a quando i sia diverso da 50.
 
== While do ==
Questo ciclo corrisponde ad una struttura decisionale a condizione in testa.
 
La sua sintassi e':
 
'''while''' condizione '''do'''
'''begin'''
istruzione 1;
istruzione 2;
...
istruzione n;
'''end''';
 
Ovvero:'''mentre'''(while) c'è una certa condizione '''fai'''(do) le istruzioni all'interno del ciclo.
Fino a quando la condizione è vera,il ciclo viene eseguito.
Tra '''begin''' ed '''end''' vanno inserite le istruzioni che cambiano il valore di un qualche cosa affinché la condizione si avveri. È importante fare attenzione che ci sia all'interno del ciclo qualcosa che modifichi il valore della condizione, altrimenti il ciclo si ripete all'infinito e il programma non giungerà mai alle righe che seguono l'istruzione '''end'''. Questo è un comune errore che con un po' di attenzione si può evitare.Se vi è una sola istruzione, '''begin''' e '''end''' possono essere omessi.
 
Ad esempio
 
...
x:=1;
'''while''' x<>5 '''do'''
x:=x+1;
...
 
In questo esempio viene eseguito quanto scritto all'interno del ciclo finché viene verificata la condizione, cioè ad x viene sommato 1 fino a che il suo valore non sia uguale a 5,e quindi la condizione iniziale del ciclo diventi falsa.
 
== Repeat Until ==
Dopo aver parlato di If...Then...Else, e dei cicli For, While Do, chiudiamo il discorso sui cicli con Repeat...Until.
 
La sua sintassi e':
...
'''Repeat'''
istruzione 1;
istruzione 2;
...
istruzione n;
'''Until''' condizione;
...
In sostanza questo ciclo ripete le istruzioni comprese tra Repeat ed Until(dall'inglese,''finchè'') fino al verificarsi della condizione espressa, detta a volte anche condizione di uscita. Anche in questo caso occorre porre attenzione al fatto che la condizione di uscita deve diventare vera in qualche modo, altrimenti finiamo in un loop infinito perdendo il controllo del programma.
 
Ad esempio
 
...
x:=1;
repeat
x:=x+1;
until x=5;
 
In questo caso,x viene sommato a 1 fino a chè il suo valore sia diverso da 5;quando x=5,si esce dal ciclo.
 
== For, While, Repeat Until==
Nel caso del ciclo '''For''' il numero di cicli eseguiti è noto, poiché il contattore parte da un elemento iniziale ed arriva fino all'elemento finale. Nel caso di '''While''' e di '''Repeat Until''' il numero di volte che viene ripetuto il ciclo generalmente non è noto a priori, in quanto dipende dal cambiamento che subisce la variabile che controlla la condizione.
C'è da notare che le istruzioni del ciclo '''Repeat Until''' verranno eseguite almeno una volta, poiché la condizione viene verificata alla fine, dopo il codice del ciclo. Mentre la condizione di ingresso di un ciclo '''while''' essendo testata prima di eseguire il codice associato al ciclo, potrebbe se questa risulta falsa non fare nulla e riprendere dalle istruzioni che si trovano dopo il ciclo; è importante quindi verificare con attenzione se il flusso di esecuzione del programma entra almeno qualche volta nel codice del ciclo, controllando se la condizione di ingresso risulta vera almeno in qualche caso.
 
=Type=
 
Abbiamo già visto prima che per dichiarare una variabile,si deve specificare un tipo (ad esempio,integer o real),per indicare quali valori può assumere.
In alcuni casi,può essere utile ricorrere a deelle tipologie di dati non predefinite;in questo caso,si può ricorrere a una ''dichiarazione di tipo'',con la parola riservata '''type'''.
 
La sintassi,in questo caso,è
'''type'''
nome:(elemento_1,elemento_2,...,elemento_n);
 
Per indicare quindi che una variabile è del tipo ''nome'',si usa la sintassi:
var
variabile:nome;
 
=Array=
 
==Vettori==
Per organizzare dei dati,a volte si ricorre a delle tabelle.
Un esempio di tabella:
{| border=1
|'''Valori'''
|valore 1
|valore 2
|valore 3
|valore 4
|valore 5
|valore 6
|valore 7
|valore 8
|valore 9
|valore 10
|-
|'''Indice'''
|'''1'''
|'''2'''
|'''3'''
|'''4'''
|'''5'''
|'''6'''
|'''7'''
|'''8'''
|'''9'''
|'''10'''
|}
 
Se diamo un nome alla tabella,ad esempio,''Array'',possiamo indicare il valore dell'elemento di indice 8 in questo modo:
Array[8]=valore 8;
così come
Array[9]=valore 9;
e così via.
 
Una struttura come quella dell'esempio precedente,può essere chiamata '''vettore''';a ogni numero (1,2,..,10) nella tabella,corrisponde un valore (valore 1,valore 2,..,valore 10);perciò la seconda colonna della tabella in questo caso si chiama ''indice'' del vettore.Il vettore consente di identificare un gruppo di dati con un nome collettivo (''Array'' dell'esempio precedente) e di potere individuare ogni singolo dato con attraverso un indice,tra parentesi quadre,che rappresenta il ''posto'' occupato dal dato nella tabella.
 
Anche in Pascal,così in altri linguaggi di programmazione,si possono strutturare i dati in maniera simile tramite gli '''array'''.
 
 
In Pascal,una variabile appartenente a un vettore(come ad esempio ''valore 1'') si dichiara con questa sintassi:
var
nome_variabile: '''array[1..n] of tipo_del_dato''';
 
Cioè,la variabile ''nome_variabile'' appartiene al vettore che ha ''n'' "posti"(le caselle della riga "Valori" della tabella) con valori del tipo ''tipo_del_dato''.;
 
Si può anche dichiarare in questo modo
 
type
nome_del_tipo='''array[1 .. n] of tipo_del_dato''';
var
nome variabile:nome_del_tipo;
 
Per leggere e scrivere gli elementi di un vettore di N posti,in Pascal,si usa il ciclo for;
 
for I:=1 to N do
readln(vettore[I]);
 
for I:=1 to N do
writeln(vettore[I]);
 
All'aumentare di I,il programma scorre i posti del vettore.
 
==Array bidimensionali==
 
Prendiamo come esempio questa tabella:
{| border=1
|
|'''1'''
|'''2'''
|'''3'''
|'''4'''
|'''5'''
|'''6'''
|'''7'''
|'''8'''
|'''9'''
|'''10'''
|-
|'''1'''
|array[1,1]
|array[2,1]
|array[3,1]
|array[4,1]
|array[5,1]
|array[6,1]
|array[7,1]
|array[8,1]
|array[9,1]
|array[10,1]
|-
|'''2'''
|array[1,2]
|array[2,2]
|array[3,2]
|array[4,2]
|array[5,2]
|array[6,2]
|array[7,2]
|array[8,2]
|array[9,2]
|array[10,2]
|-
|'''3'''
|array[1,3]
|array[2,3]
|array[3,3]
|array[4,3]
|array[5,3]
|array[6,3]
|array[7,3]
|array[8,3]
|array[9,3]
|array[10,3]
|}
 
Nel vettore,il posto nella tabella era individuato da un indice;nella tabella bidimensionale,invece,da una coppia di indici.
Una tabella bidimensionale è anche chiamata '''matrice'''.
 
Si può dichiarare una matrice in modo simile a come si dichiare un vettore:
 
var
nome_variabile:'''array[1 .. n,1 .. m] of tipo_del_dato''';
 
oppure
type
nome_del_tipo = '''array[1 .. n, 1 .. m] of tipo_del_dato''';
var
nome variabile: nome_del tipo;
 
Per leggere e scrivere i dati di una matrice di N righe e M colonne,in Pascal,si usano due cicli for uno dentro l'altro;
 
for I:=1 to N do
for J:=1 to M do
readln(array[I,J]);
 
for I:=1 to N do
for J:=1 to M do
writeln(array[I,J]);
 
= Tool =
== Compilatori ==
* A pagamento
** Borland Pascal
 
* Open Source
** Free Pascal
** GNU Pascal
 
== IDE ==
*A pagamento
** Borland Delphi
** '''Borland Turbo Pascal'''
 
* Open Source
** [http://lazarus.freepascal.org Lazarus]
** [http://www.bloodshed.net/dev/pascal.html Dev-Pas]
** [http://www.freepascal.org FreePascal]
 
Da notare che Borland Delphi e Lazarus sono IDE di Delphi ovvero Pascal orientato agli oggetti, riescono tuttavia a compilare senza problemi il Pascal normale.
 
[[Categoria:Linguaggi di programmazione]]
11 473

contributi