Pascal (linguaggio di programmazione)

Da Wikipedia, l'enciclopedia libera.
(Reindirizzamento da Pascal (linguaggio))
Pascal
Autore Niklaus Wirth
Data di origine 1970
Utilizzo generico, didattico
Paradigmi programmazione strutturata
Tipizzazione forte, statica
Specifiche di linguaggio Pascal user manual and Report
Estensioni comuni .pas, .inc
Influenzato da ALGOL

Il Pascal è un linguaggio di programmazione creato da Niklaus Wirth. Si basa sul linguaggio ALGOL e fu così chiamato in onore del matematico e filosofo francese Blaise Pascal, inventore della prima macchina calcolatrice automatica.

Storia[modifica | modifica sorgente]

Wirth era un docente di programmazione e sentiva la mancanza di un vero linguaggio di programmazione adatto alla didattica e che fosse dotato di strutture dati avanzate. Il BASIC, creato nel 1964, era facile da imparare ma non aveva strutture dati avanzate e soprattutto non incoraggiava affatto ad analizzare il problema da risolvere prima di scrivere il codice. Perciò, Wirth creò da zero il Pascal, inserendo nel linguaggio il concetto di programmazione strutturata.

La prima implementazione del linguaggio divenne operativa nel 1970, ma raggiunse una discreta diffusione nel campo industriale nel 1973 con la pubblicazione del testo: "Pascal user manual and Report". Questo è il testo di riferimento standard per il linguaggio.

TeX e buona parte delle prime versioni del sistema operativo del Macintosh e di Microsoft Windows furono scritte in Pascal.

Essendo un linguaggio pensato per degli utenti inesperti, spesso i compilatori Pascal hanno un atteggiamento materno nei confronti del programmatore, partendo dal presupposto che qualunque irregolarità del codice scritto sia un errore, che infastidisce un po' gli esperti. In cambio è un linguaggio completo e potente, e soprattutto educa fin dall'inizio ad adottare un buono stile di programmazione e ad analizzare a fondo il problema prima di cominciare a scrivere il codice, cosa che rende i programmi Pascal più chiari e più facili da leggere.

Data la diffusione negli ambienti scolastici, ne sono state create versioni ad oggetti, come il Turbo Pascal e l'Object Pascal (utilizzato nell'ambiente di sviluppo Delphi di Borland).

Caratteristiche[modifica | modifica sorgente]

Le caratteristiche principali del Pascal sono una sintassi molto chiara e molto rigida con l'obbligo di dividere il programma in sezioni ben definite (uses, implementation) e di dichiarare in anticipo tutte le variabili usate nel programma (var, const); permette l'uso di tipi di dati complessi e definibili dal programmatore (i record) tramite la sezione type; permette (con alcune rigidità) l'uso dei puntatori e l'allocazione dinamica della memoria (new e dispose). Il Pascal è pertanto classificato come linguaggio semidinamico, in quanto gestisce i puntatori, permettendo di creare liste di variabili di dimensione non nota all'atto della compilazione, ma questi possono essere solo di un tipo alla volta, il tipo usato per definire la variabile puntatore stessa. Al posto delle subroutine di uso comune nei linguaggi di allora, il Pascal introduce le procedure e le funzioni, che estendono il concetto di subroutine incapsulando al loro interno le variabili e i dati locali, ed esponendo solo i valori in ingresso ed in uscita. Inoltre, nella sua formulazione originale, era privo dell'istruzione GOTO, aggiunta poi in seguito con riluttanza.

IDE gratuiti[modifica | modifica sorgente]

Programmi di esempio[modifica | modifica sorgente]

Hello, world![modifica | modifica sorgente]

Il seguente esempio stampa a video il testo "Hello world".

program hello;         <----non obbligatoria
uses crt;              <----non obbligatoria
begin
  clrscr;              <----non obbligatoria
  writeln('Hello World');
  readln
end.

Note La prima riga introduce il programma con la parola chiave program, a cui segue il titolo del programma. Non possono essere utilizzati caratteri speciali né spazi. La terza riga contiene l'istruzione begin, usata per iniziare a scrivere il programma vero e proprio. La quinta riga contiene l'istruzione writeln, usata per scrivere a video il testo ("Hello World") riportato tra parentesi, mentre la sesta, con l'istruzione readln, pone il programma in attesa di un input da tastiera, in modo da non far scomparire immediatamente la scritta. Quando verrà premuto il tasto invio, il programma procederà eseguendo l'istruzione end, che pone fine alla sequenza. Tale comando è l'unico, in ambiente Pascal, ad essere seguito da un punto anziché da un punto e virgola.


Variabili[modifica | modifica sorgente]

Il Pascal mette a disposizione molti tipi di variabili:

  • Tipi interi, utilizzati per memorizzare valori numerici interi, con o senza segno e compresi entro determinati intervalli numerici. In Pascal sono:
    • integer: variabile di tipo intero a 16 bit con segno (numeri da -32768 a 32767)
    • word: variabile di tipo intero a 16 bit senza segno, copre i valori da 0 a 65535.
    • byte: come già suggerisce il nome, questo tipo occupa 1 byte in memoria e consente 2^8=256 differenti valori, nel dettaglio da 0 a 255. Questo tipo è completamente compatibile con il tipo char, l'unica differenza consiste nel fatto che un tipo byte ha come visualizzazione predefinita quella di un numero, mentre il char quella di un carattere.
    • short: come il precedente occupa un solo byte ma i valori possono variare da -128 a 127.
    • longint: occupa 4 byte (e quindi 4x8=32 bit) e permette quindi di gestire 2^{32}=4294967296 diversi valori, compresi fra -2147483648 e 2147483647.
    • comp: è il tipo intero più grande. Occupa 8 byte (64 bit), pertanto permette di gestire 2^{64}=18446744073709551616 diversi valori, compresi tra -9.2E18 e 9.2E18.
  • Tipi reali:
    • real: numero reale (numeri da -2.9E-39 a 1.7E38), se nello stampare a video risultati reali ottenete numeri incomprensibili è perché essi sono scritti notazione scientifica o esponenziale. Se si inseriscono da tastiera numeri real, bisogna scriverli in notazione esponenziale. Per stampare a video un numero reale in formato decimale utilizzare la seguente sintassi:
... {Altre istruzioni}
Var R:Real;
... {Altre istruzioni}
Writeln('Il numero reale è ',R:10:3);
... {Altre istruzioni}

In questo caso vengono visualizzate in tutto 10 cifre, di cui 3 decimali.

  • Tipo carattere (char): variabile carattere, contiene 1 solo carattere.
  • Tipo booleano (boolean): variabile binaria (vero/falso).

Array[modifica | modifica sorgente]

Gli array in Pascal sono una sequenza ordinata, in una quantità prestabilita, di elementi dello stesso tipo. Gli elementi possono essere composti da qualunque tipo di dati, nativo o definito dal programmatore.

Una caratteristica importante del linguaggio Pascal sta nel fatto che nel momento della dichiarazione di un array, viene definito anche il valore iniziale dell'indice da utilizzare per la scansione dei vari elementi:

  • Array di un tipo generico:
Var nome : array [inizio..fine] of tipo;
  • Stringhe: Come in molti altri linguaggi le stringhe sono semplicemente degli array di caratteri. La dichiarazione di una variabile stringa è quindi la dichiarazione di un array composto da una quantità predefinita di caratteri. Nell'esempio seguente viene creato una variabile stringa di 20 caratteri. La variabile dichiarata in questo modo può essere usata come un array, cioè accedendo alle informazioni carattere per carattere oppure nel suo insieme. Se si utilizza un assegnamento di quest' ultimo tipo vengono ricoperti anche gli elementi successivi alla lunghezza della stringa letterale assegnata. Quindi, seguendo l'esempio, l'array riceve il nome «Paolo» nei suoi primi cinque elementi, mentre negli altri viene comunque inserito uno spazio.
Var nome : array [1..20] of char;
..... {Altre istruzioni}
nome := 'Paolo'; {assegnazione nel suo insieme}
nome[5] :='a';  {assegnazione del solo quinto carattere}

Input e output[modifica | modifica sorgente]

L'input di dati da tastiera, viene effettuato tramite l'utilizzo del comando readln(nome_variabile).
L'output invece usa il comando writeln(nome_variabile); la stampa a video usa lo stesso il comando writeln, però il testo è tra apici ' ' (writeln('ciao mondo');)
I/O di interi:

program input_output(input, output);
var 
     n1,n2,ris:integer;               {Dichiarazione tipo intero}
begin
     writeln('Inserisci n1');         {viene visualizzato il testo tra ' '}
     readln(n1);                      {comando di input, la variabile introdotta viene inserita in n1}
     writeln('Inserisci n2');
     readln(n2);
     ris:=n1+n2;                      {fa la somma di n1 e n2 e il risultato viene inserito in ris}
     writeln('La somma e'' uguale a ',ris);     {stampa il messaggio tra ' ' e la variabile ris}
     readln;     {questo evita che il programma si chiuda senza che sia possibile leggere l'ultima riga, il programma si
                  aspetta che l'utente scriva qualcosa e poi prema INVIO. In questo modo il programma si chiuderà.}
end.

I/O reali: per l'input di numeri reali il metodo resta sempre lo stesso (readln (variabile)),
invece per l'output, per vedere numeri comprensibili bisogna usare una sintassi diversa nel writeln

program input_output(input, output);
var   n1,n2,ris:real;                  {Dichiarazione tipo reale}
begin
     writeln('Inserisci n1');         {viene visualizzato il testo tra ' '}
     readln(n1);                      {comando di input, la variabile introdotta viene messa in n1}
     writeln('Inserisci n2');
     readln(n2);
     ris:=n1+n2;                      {fa la somma di n1 e n2 e il risultato viene messo in ris}
     writeln('La somma e'' uguale a ',ris:6:2);  
{stampa il messaggio tra ' ' e la variabile ris, con 6 numeri prima della "," , la "," stessa e 2 dopo}
     readln;
end.

Nella stampa a video abbiamo usata una 'modifica' del comando writeln: la modifica sta nell'aggiungere var:n:m dove var è il nome
della variabile da visualizzare, n è il numero di cifre complessive (compresa la ",") da visualizzare e m sono quelle dopo la virgola.
Se ci sono più cifre da visualizzare di quelle indicate, esse non vengono fatte vedere.(formattazione dell'output)

I/O caratteri: l'input e l'output di caratteri (numeri, lettere, simboli), è molto semplice da effettuare, per il semplice motivo che è lo stesso metodo di i/o dei numeri interi

program input_output(input, output);
var   ch:char;               {Dichiarazione tipo carattere}
begin
     writeln('Inserisci il carattere');         {viene visualizzato il testo tra ' '}
     readln(ch);                      {comando di input, la variabile introdotta viene messa in ch}
     writeln('Il carattere inserito e'' ',ch);     {stampa il messaggio tra ' ' e la variabile ch}
     readln;
end.

I/O stringhe: le variabili stringhe in effetti non sono altro che array di char (vettori di caratteri). Questo esempio è veramente semplice in confronto alle potenzialità del Pascal, difatti con questo linguaggio si possono creare vere e proprie applicazioni.

Strutture di controllo[modifica | modifica sorgente]

Alternative[modifica | modifica sorgente]

Program alternativa;
var 
   n:integer;
begin
 write('inserisci un numero: ');
 readln(n);
 if n > 0     {controlla se il valore è positivo}
  then
    write('il numero e'' positivo.')
  else
    write('il numero e'' negativo.');
 readln;
end.

Iterazione[modifica | modifica sorgente]

I seguenti pezzi di programmi sono un esempio dei cicli di Pascal.

Program ciclo_for;
var i, n, num:integer;
begin
 write('quanti numeri vuoi inserire?');
 readln(n);
 for i:=1 to n do
  begin
   write('inserisci il numero: ')
   readln(num);
  end;
 readln;
end.

Iniziamo subito con il dire che, dopo la parola for, ci vuole l'assegnamento ad una variabile di un valore (in questo caso i:=1). Questa stessa variabile verrà incrementata automaticamente dal computer ad ogni step e, una volta uguale al numero (o alla variabile) dopo il to, il ciclo terminerà. Da notare è anche il fatto che il valore di una variabile può essere incrementato anche usando la stessa variabile come riferimento. Infatti l'algebra non permetterebbe espressioni del tipo x=x+q, perché, risolvendo l'equazione, si otterrebbe 0=q e sarebbe (con q diverso da 0) una cosa assurda (se invece q fosse 0, verrebbe x=x, che è abbastanza ovvio). Il Pascal invece, come del resto tutti gli altri linguaggi, permette questa sintassi, molto comoda (anche se non la migliore, infatti, linguaggi di alto livello come il C++ e il Vb.Net, nonché il Java, hanno una sintassi ancora più breve, x+=q, che equivale a quanto scritto in precedenza). Tornando a noi, il ciclo for...to...do ripete un blocco di istruzioni un numero determinato di volte, ragion per cui, sono assolutamente vietati valori reali decimali prima e dopo il to, e quindi le variabili dovranno essere dichiarate integer.

Program Esempio2;
Uses Crt,WinDos;
Var nome1,nome2,stringa:string;
 file1,file2:text;
begin
 clrscr;
 write('Inserire il nome di un file: ');
 readln(nome1);
 write('Inserire il nome del file copia: ');
 readln(nome2);
 Assign(file1,nome1);
 Assign(file2,nome2);
 Reset(file1);
 Rewrite(file2);
 repeat
  readln(file1,stringa);
  writeln(file2,stringa);
 until eof(file1);
 Close(file1);
 Close(file2);
 writeln('Copia completata!');
 readln
end.

Assign(nome1,file1); : questa procedura assegna alla variabile file 1 di tipo text il nome del file contenuto nella stringa nome1. Per questo, è doveroso aprire una parentesi su come Pascal legge i nomi dei file: innanzitutto, un nome può essere composto da al massimo 8 caratteri, estensione esclusa; se il nome supera gli 8 caratteri viene troncato a 6 e si aggiunge un ~1 (il codice ASCII di ~ è 126). Perciò il nome testouno.txt è giusto e viene mantenuto così; testoquattro.txt è sbagliato e il compilatore vi manderà un messaggio di errore (error 2: File not found); testoq~1.txt è la versione giusta dell'esempio precedente: i caratteri vengono troncati a 6 e aggiunto un ~1. Reset(file1); : listruzione reset(x), dove x è una variabile inizializzata con Assign e di tipo text o file, serve per aprire il file x, in vista di operazioni di lettura/scrittura su di esso. Rewrite(file2); : valgono le stesse regole di reset. Rewrite(x:text o file) è una procedura che crea un nuovo file x (se non è specificata la directory nel suo nome, viene creato nel path corrente). Se esiste già un file di nome x, lo sovrascrive.

repeat...until eof(file1); : ripete un ciclo di istruzioni finché l'espressione indicata dopo until è vera. Nel nostro caso, il programma continua a leggere, riga per riga, ogni sequenza di caratteri contenuta in file1 e la copia in file2, finché la variabile reimpostata eof (che significa End Of File; supporta solo parametri di tipo text o file) non è vera (se non si mette un segno di comparazione, il compilatore sottintende un =true), e quindi il file da cui leggere è al termine.

Close(file1); : la procedura close chiude un file.

Questo programma è già di un livello più alto: meriterebbe uno studio più accurato per capire il funzionamento, da parte del lettore.

Come si è ben visto, il ciclo repeat...until serve per ripetere un'istruzione o un blocco di istruizioni fino a che una condizione non è vera: come avrete sicuramente notato, in questo caso non serve racchiudere il blocco di istruzioni fra un begin ed un end, poiché i confini del blocco sono già repeat e until.

Program esempio3;
Uses Crt;
Var x,y:word;
 
begin
 clrscr;
 write('Inserire due coordinate: ');
 readln(x,y);
 while (x<>0) and (y<>0) do
  begin
   read(x,y);
   gotoxy(x,y);
   write((,x,;,y,));
  end;    
 readln;
end.

Questo programma legge da tastiera due coordinate, sposta il cursore a quelle date coordinate e scrive in quel punto le ascisse e le ordinate tra parentesi, separate da un punto e virgola. Il ciclo si ripete ogni volta che la condizione indicata è vera: in questo caso quando sia x che y sono diversi da 0. La procedura gotoxy(x,y:word) sposta il cursore alle coordinare (x;y) sullo schermo. In pratica, scrivere:

while (x<>0) and (y<>0) do
 begin
 ...
 end;

è come scrivere:

repeat
...
until (x=0) and (y=0);

Anche con while è opportuno stare attenti ai cicli infiniti e bisogna notare che con il while è necessario includere il blocco di istruzioni fra begin ed end;

Note[modifica | modifica sorgente]

  1. ^ Free Pascal - Un compilatore Pascal Open Source avanzato per Pascal e Object Pascal
  2. ^ Lazarus Project :: Write once compile everywhere!
  3. ^ Bloodshed Software - Providing Free Software to the Internet community

Voci correlate[modifica | modifica sorgente]

Altri progetti[modifica | modifica sorgente]

Collegamenti esterni[modifica | modifica sorgente]

informatica Portale Informatica: accedi alle voci di Wikipedia che trattano di informatica