Un MANUALETTO di LINGUAGGIO
PASCAL per il biennio
Parte A
1) ESEMPIO INTRODUTTIVO
|
Esempio |
Osservazioni |
|
program pitagora; uses crt; var a, b, c:
integer; begin clrscr; writeln ('Inserisci le
misure dei tre lati del triangolo'); writeln ('Devono essere
numeri interi in ordine crescente'); readln (a); readln (b); readln (c); if a*a+b*b=c*c then
write ('Il triangolo è rettangolo') else write ('Il
triangolo non è rettangolo'); readln; end. |
uses crt è la chiamata di un programma “di
servizio” var precede l’elenco delle variabili col
rispettivo tipo Il “corpo”
del programma è sempre preceduto da “begin” clrscr da
CLeaR-SCReen: istruz di “pulizia dello schermo” write=scrivi, writeln=”scrivi-poi-vai-a-capo read=leggi, readln=leggi-poi-dopo-aver-letto-vai-a-capo if …
then … else …
significa: se … allora … altrimenti … “readln”
prima dell’ ”end” finale
inserisce una pausa Il
programma termina sempre con “end.” |
·
Le
istruzioni e le dichiarazioni di un programma TURBO PASCAL possono essere scritte
indifferentemente in minuscolo o in maiuscolo.
·
uses crt è
la chiamata di un programma “di servizio” senza il quale il nostro programma
non sarebbe in grado di eseguire la successiva istruzione “clrscr” per la
pulizia dello schermo
·
La
rientranza, o “INDENTAZIONE”, di alcune righe del programma rispetto ad altre,
non è obbligatoria ma è utilissima per migliorare la “leggibilità” del
programma.
·
“readln”
prima dell’ ”end” finale inserisce una pausa senza la quale il computer
eseguirebbe immediatamente l’ ”end” finale e ritornerebbe quindi subito a
mostrare sullo schermo la videata delle istruzioni del programma, senza che
l’utente possa avere il tempo di osservare l’output.
2) ISTRUZIONI DI INPUT-OUTPUT E DI ASSEGNAZIONE
write (‘Carissima ti bacio ‘, x, ‘ volte’);
Scrivi
la stringa “Carissimo ti bacio “, poi
il valore della variabile x (ossia: il contenuto della scatoletta x), poi la
stringa “ volte”
writeln
(‘a+b = ‘, a+b);
Scrivi
la stringa “a+b = “, poi il valore dell’espressione a+b (ossia: il valore della
somma dei contenuti delle scatolette a, b);
infine,
vai a capo col cursore (writeln e non write)
read (a);
Leggi
ciò che l’utente digita sulla tastiera e “mettilo nella scatoletta a”, ossia:
assegnalo come valore alla variabile a
readln (a);
Come
prima; alla fine, però, vai a capo col cursore.
num:=5;
Assegna
alla variabile num (cioè: metti nella scatoletta num) il valore 5
y:=a+b;
Assegna
alla variabile y (=metti nella scatoletta y) il valore dato dalla somma dei
valori che in quel momento hanno le variabili a, b (cioè: che in quel momento
stanno nelle scatolette a, b).
Si
dice: assegna alla variabile y la somma dei valori attuali delle
variabili a, b.
c:=c+1;
Assegna
alla variabile c (ossia: metti nella scatoletta c) il valore che c aveva
precedentemente, aumentato di 1
(quindi,
in pratica: incrementa di una unità il valore della variabile c)
Esempi
|
|
|
|
|
program moltiplicazioni_uno; var a, b:
integer; begin readln (a); readln (b); writeln (a*b); readln; end. OSSERVAZIONI: a*b: il
simbolo di moltiplicazione non si può sottintendere all’interno di una
espressione matematica in Pascal, e si realizza con un asterisco. moltiplicazioni_uno: notare il carattere “di sottolineatura” che lega fra loro le due
parole; infatti, in TURBO PASCAL, un nome di programma o di variabile (=un
“identificatore”), non può contenere spazi vuoti readln: istruzione indispensabile se si vuole avere tempo di osservare l’output: prova a toglierla, fai correre e vedrai cosa succederà! |
program moltiplicazioni_due; uses crt; (*questo programma è simile al precedente, è solo un po’ più
ricco*) var a, b, prod:
integer; begin clrscr; write (‘a= ‘); readln (a); write (‘b= ‘); readln (b); prod:=a*b; write (‘a*b = ‘); writeln (prod); readln; end. OSSERVAZIONI: (* *) Le “parentesi
asteriscate” consentono di inserire un commento in un punto qualsiasi del
programma. write (‘a =
‘) fa sì che
l’utente possa capire “cosa deve fare”. |
program moltiplicazioni_tre; uses crt; var a, b:
integer; begin clrscr; write (‘a= ‘); readln (a); write (‘b= ‘); readln (b); write (‘a*b = ‘, a*b); readln; end. OSSERVAZIONI: Organizzando
il programma in questo modo, possiamo evitare di introdurre la variabile
“prod” Una
variante simpatica avrebbe potuto essere write (a, ‘*’, b, ‘=’, a*b) Dimmi: che differenza avremmo avuto sul monitor? |
3)
I
PRINCIPALI TIPI DI VARIABILI NUMERICHE;
CENNI ALLE VARIABILI “STRINGA”
I principali tipi di
variabili numeriche
|
Specie |
Tipo |
Range |
n° di cifre decimali significative |
|
Intera |
Integer |
-32768 … +32767 |
|
|
Intera |
Longint |
-2147483648…+2147483647 |
|
|
Reale |
Real |
2.9 * 10-39… 1.7 * 1038 |
Da 11 a 12 |
|
Reale |
Double |
5.0 * 10-324…
1.7 * 10308 |
Da 15 a 16 |
|
Reale |
Extended |
3.4 * 10-4932
… 1.1 * 104932 |
Da 19 a 20 |
Program esempio_per_capire_le_variabili_stringa;
uses crt;
var nome: string [20]
begin
clrscr;
writeln (‘Come ti
chiami?’);
readln (nome);
writeln (‘Buona
giornata ‘, nome, ‘ !!! ‘);
readln;
end.
“nome”
è una variabile stringa:
la
“scatoletta” nome non è destinata a contenere un numero, bensì una “stringa”,
ovvero una sequenza di caratteri.
Il
numero [20] entro parentesi quadre indica che la stringa potrà avere una
lunghezza massima di 20 caratteri.
4) IF… THEN … ELSE … (=LA STRUTTURA DI SELEZIONE)
if
a*a+b*b=c*c then write ('Il triangolo è rettangolo') else write ('Il triangolo
non è rettangolo');
In generale, la struttura
IF condizione THEN
istruzione 1 ELSE istruzione 2
ordina al computer di:
·
controllare
se è verificata la condizione;
·
in
caso affermativo, eseguire l’istruzione 1, in caso negativo eseguire l’istruzione
2.
if a*a+b*b=c*c then
begin
writeln ('Il triangolo è rettangolo');
writeln (‘perchè la somma dei quadr. di due lati uguaglia il quadr. del terzo’)
end
else write ('Il triangolo non è rettangolo');
Notare
in questo esempio l’uso degli indicatori di INIZIO BLOCCO (begin) e FINE BLOCCO
(end).
if media<3 then media:=3;
Questa istruzione potrebbe far parte di un
programma nel quale un insegnante indulgente decida di "alzare" al 3,
per non infierire, la media di un suo alunno nel caso questa risulti minore di
3;in caso contrario, cioè se la media è maggiore o uguale a 3, essa non verrà
modificata).
L’esempio
chiarisce che l’ELSE non è sempre obbligatoria nell’ambito di una IF.
ATTENZIONE: prima dell’ ELSE
non ci vuole mai il “punto-e-virgola” (errore frequente)
|
|
|
|
Program equazioni_strane_1;
uses crt; var a, b, x:
real; begin clrscr; write (‘Risolviamo
l’’equazione ax=b’); write (‘a = ‘); readln (a); write (‘b = ‘); readln
(b); IF a<>0 THEN begin x:=b/a; write (‘x = ‘, x); end ELSE IF b<>0 THEN write (‘Eq. Impossibile’) ELSE write (‘Eq. Indeterminata’) readln; end. Qui abbiamo dato un esempio di due IF … THEN
… ELSE … “annidate” |
Program equazioni_strane_2;
uses crt; var a, b, x:
real; begin clrscr; write (‘Risolviamo
l’’equazione ax=b’); write (‘a = ‘); readln (a); write (‘b = ‘); readln
(b); if a<>0 then write (‘x = ‘, b/a) if a=0 AND b<>0 then write ‘Eq.
Impossibile’) if a=0 AND b=0 then write ‘Eq. Indeterminata’) readln; end. L’uso dell’operatore logico AND ci ha permesso di scrivere il
programma in modo più semplice. Gli operatori logici in Turbo Pascal
sono AND, OR, NOT,
XOR (XOR= disgiunzione esclusiva: p XOR q è vera se e solo se è vera
una e una sola delle due condizioni p, q) |
Esercizio 1:
Nel 1969 l’uomo è atterrato per la prima volta sulla Luna.
Scrivi un programma Pascal che domandi all’utente il suo anno di
nascita e fornisca un output del tipo:
“Quando l’uomo sbarcò sulla Luna tu avevi … anni”
“Quando l’uomo sbarcò sulla Luna tu non eri ancora nato: saresti
nato … anni dopo”
“Caspita, ma sei nato proprio l’anno in cui l’uomo sbarcò sulla
Luna!!!”
LA
“SELEZIONE MULTIPLA”: CASE … OF …
Quando le alternative sono più di due, potrà essere utile una
nuova struttura di selezione: la CASE … OF …
illustrata dal seguente esempio:
CASE punteggio OF
0: begin
writeln
(‘Tutte le tue risposte sono sbagliate!’);
writeln
(‘L’’hai fatto apposta?’);
end;
1, 2: writeln (‘Vai a zappare’);
3, 4: writeln (‘Gravemente insufficiente’);
5: writeln
(‘Insufficiente’);
6 .. 9: writeln (‘OK’);
10: writeln (‘Tutto
giusto!’);
END;
L’istruzione
writeln;
provoca
l’effetto di spostare il cursore all’inizio della riga successiva; se il
cursore SI TROVA GIA’ all’inizio di una riga, l’effetto sarà di passare
all’inizio della riga successiva, e quindi di saltare una riga
APOSTROFO NELLE STRINGHE:
CHE GUAIO! IL COMPUTER LO CONFONDE CON IL SIMBOLO DI
“FINE STRINGA”!
writeln
(x:20:5); x
è una variabile di tipo REAL; l’istruzione ordina al computer di scriverne il
valore in notazione NON esponenziale, utilizzando uno spazio (detto
“ampiezza”)di 20 caratteri (il numero verrà allineato a destra nell’ambito di
questo spazio), e con esattamente 5 cifre dopo il punto decimale
writeln
(k:8); k è
una variabile di tipo INTEGER; l’istruzione ordina al computer di scriverne il
valore utilizzando uno spazio di 8 caratteri (il numero verrà allineato a
destra nell’ambito di questo spazio)
Esercizio 2:
Realizza un programma Pascal che operi
come segue:
letto in ingresso un numero x, si fornisce
in output:
·
la radice quadrata di x, in notazione NON ESPONENZIALE, se
k>=0;
·
la scritta "Mi spiace, ma non esiste la radice quadrata di un
numero negativo" in caso contrario.
NOTA L’operatore Pascal che calcola la
radice quadrata di un numero x, è sqrt(x) (sqrt = SQuare RooT)
L’istruzione per ottenere in output un testo colorato è
textcolor (n);
dove n è il codice del colore desiderato
( 0 <= n <= 15; aggiungendo 16 al codice di ciascun colore,
se ne ottiene la versione “lampeggiante”).
Ad esempio:
1 = blu, 2 = verde, 4=rosso, 9 = azzurro, 14 = giallo, 15 =
bianco; 17=blu lampeggiante, 18 = verde lampeggiante, …
Per conoscere le altre
corrispondenze codice-colore, possiamo scrivere un programmino apposito, ad
esempio un programma che, letto in input un intero, lo restituisca in output,
colorato del colore che gli corrisponde.
Semplice:
program codici_dei_vari_colori;
uses crt;
var n: integer;
begin
clrscr;
writeln (‚Scrivi un intero compreso fra 1
e 30 e io ti farò sapere di quale colore esso è il codice’);
write (‘n = ‘);
readln (n);
textcolor (n);
write (n);
readln;
end.
L’istruzione
delay (n);
ordina al computer di attendere n millisecondi prima di eseguire
l’istruzione successiva.
A dire il vero ciò non è proprio esatto: anche se i libri di testo
parlano in genere di “millisecondi”, in realtà il ritardo prescritto
dall’istruzione delay (n) è diverso, per uno stesso n, a seconda della velocità del microprocessore.
Bisognerà perciò scegliere n a seconda delle esigenze … e del
microprocessore in uso.
Nel “corpo” di un programma si possono scrivere
dei “commenti”, che vengono ignorati dal “compilatore” (ossia dal programma che
traduce il programma scritto in linguaggio Pascal in un programma scritto in
linguaggio macchina (=sequenze di bit), quindi “comprensibile” ed eseguibile da parte della macchina.
I commenti devono essere inseriti fra “parentesi
asteriscate”
(* questo è un commento *)
oppure fra parentesi graffe
{ questo è un commento }
Le graffe non compaiono sulla tastiera e si
realizzano mediante ALT-1-2-3 (graffa aperta) e ALT-1-2-5 (graffa chiusa).
6) NUMERI
CASUALI (O MEGLIO, “PSEUDOCASUALI”)
bigliettino:=random (5);
“bigliettino”
è una variabile di tipo integer; l’istruzione le fa assumere un valore casuale,
o meglio “pseudocasuale” (“random” in inglese significa “caso”) che potrà
essere 0, 1, 2, 3 oppure 4
In TURBO PASCAL la funzione RANDOM (n) genera un integer pseudocasuale che potrà valere: 0, 1, 2, …, n-1.
Quindi, ad esempio,
esito:=random(2)
si presta a simulare il lancio di una
moneta (1 potrà essere interpretato come “Testa” e 0 come “Croce, o viceversa;
x:=random(6)+1
si presta a simulare il lancio di un dado.
Invece la funzione random, usata senza alcun argomento, restituisce un numero pseudocasuale di tipo real , compreso fra 0 e 1.
Es.
x:=random;
assegna alla variabile x, che deve essere
stata dichiarata di tipo “real”, un valore pseudocasuale compreso fra 0 e 1.
E’ ’importante ricordarsi che quando in un
programma Turbo Pascal si utilizza una funzione random, occorre premettere, all’inizio del programma
(o comunque prima dell’istruzione che contiene la RANDOM), l’istruzione
RANDOMIZE;
essa ordina al computer di “rendere casuale il seme del
generatore di numeri pseudocasuali”.
E’ un po’ come scuotere preventivamente
l’urna da cui si estrarranno le palline; se non lo si fa, la pallina estratta,
quando viene posata, resterà sempre in superficie e continuerà ad essere
ripescata
Esercizio 3:
Scrivi
un programma Pascal che operi nel seguente modo:
BAMBINO, CHE OPERAZIONE VUOI FARE? + OPPURE *?
il simbolo +
o in alternativa il simbolo
*
e il computer “leggerà” il
carattere scelto)
9*7=
GIUSTO!
oppure
SBAGLIATO
a seconda dei casi.
Insomma,
al termine dell’esecuzione il monitor deve apparire (ad esempio) così:
BAMBINO,
CHE OPERAZIONE VUOI FARE? + OPPURE *?
+
2+7=8
SBAGLIATO
dove, evidentemente, il bambino ha digitato
esclusivamente il simbolo + della seconda riga e il numero 8, mentre tutto il resto lo ha scritto il computer.
.7 ) GLI OPERATORI “DIV” E “MOD”;
PARI? DISPARI? DIVISIBILE PER…? DIVISORE DI …?
GLI
OPERATORI “DIV” E “MOD”
30 DIV 7 = 4; 30 MOD 7 = 2; 15 DIV 3 = 5; 15 MOD 3 = 0; … insomma,
a DIV b
dà il QUOZIENTE INTERO,
a MOD b
dà il RESTO.
a, b devono essere
numeri o variabili integer.
Per fare esercizi,
trascrivi il seguente programmino:
program
esercizi_sul_div_e_sul_mod; uses crt;
var a, b, x, y: integer;
begin
clrscr;
for i:=1 to 10 do
BEGIN
write ( ‘a = ‘);
readln (a);
write ( ‘b = ‘);
readln (b);
write ( a, ‘ div
‘, b, ‘ = ‘ ); readln (x);
write ( a, ‘ mod
‘, b, ‘ = ‘ ); readln (y);
if (x = a div b) and (y = a mod b)
then writeln (‘OK’)
else
begin
writeln (‘NO. Risultati esatti: ‘);
writeln ( a, ‘ div ‘, b, ‘ = ‘, a div b);
writeln ( a, ‘ mod
‘, b, ‘ = ‘ , a mod b);
end;
END;
readln;
end.
If a mod b = 0 … significa (come preferisci):
·
“se a è divisibile per b …”
·
“se a è multiplo di b …”
·
“se b è divisore
di a …”
e perciò:
If x mod 2 = 0 … significa: “se x è pari …”.
If x mod 2 = 1 … (oppure: if x mod 2<>0) significa: “se x è dispari…”