|
L'origine del linguaggio Pascal Il Pascal è un linguaggio di programmazione ad alto livello, cioè si avvicina di più all'inglese scritto e si allontana dal linguaggio macchina, inoltre ad ogni istruzione del codice sorgente corrispondono diverse istruzioni in codice binario (nei linguaggi a basso livello ad ogni istruzione del codice sorgente corrisponde una sola istruzione in codice binario).Fu progettato per elaboratori elettronici nel 1969 da Niklaus Wirth, docente presso il Politecnico di Zurigo. Esso prende il nome da Blaise Pascal, un matematico francese, che fu il primo ad inventare una macchina calcolatrice: la Pascalina. Il Pascal si è rivelato utile a livello didattico per l'insegnamento dei metodi di programmazione. Esso si diffuse dapprima negli ambienti scientifici ma successivamente, grazie alla sua semplicità si diffuse dappertutto. Oggi il linguaggio Pascal è poco usato per applicazioni professionali, a vantaggio di altri linguaggi più adatti a sfruttare le potenzialità del sistema operativo (C, C++, Visual Basic ecc.), ma è un ottimo strumento per iniziare a programmare data la sua semplicità.
La struttura di base di un programma scritto in Pascal è costituita da 5 elementi:
Ogni riga di un programma scritto in Pascal deve necessariamente terminare con un punto e virgola (;), questa regola non è valida per righe contenenti istruzioni particolari illustrate successivamente in questa guida. Tutto il testo del programma, chiamato anche codice sorgente, può essere scritto indifferentemente sia in maiuscolo che in minuscolo.
Struttura base:
Program NOMEDELPROGRAMMA; intestazione var VARIABILI:TIPOVARIABILI; riga che dichiara le variabili begin istruzione che dichiara l'inizio del programma ... ... corpo del programma ... readln; end. istruzione che dichiara la fine del programma
L'istruzione READLN prima di END (obbligatoria nei compilatori più recenti), serve a bloccare lo schermo alla fine dell'esecuzione del programma; praticamente il compilatore aspetta che sia premuto un tasto per passare all'istruzione successiva, cioè END, e quindi terminare l'esecuzione del programma. Senza READLN il programma viene eseguito lo stesso, ma il compilatore non fermandosi alla fine non permette la corretta visualizzazione dell'esecuzione.
Torna su é L'intestazione di un programma scritto in Pascal è costituita dalla parola PROGRAM seguita da uno spazio e dal nome del programma. Il nome del programma non viene letto dal compilatore, quindi può essere un nome qualunque. Pur tuttavia la riga dell'intestazione può essere omessa, cioè si può cominciare a scrivere il programma direttamente dalla riga delle variabili.
Se si vogliono inserire degli spazi all'interno del nome del programma si possono usare le lineette (_):
Program hfdjdh_kjeijie_ijeiie; ...
Il nome del programma non viene letto dal compilatore, quindi può essere formato anche da un insieme di lettere alla rinfusa. In questo caso ho usato le lineette per simulare gli spazi e l'intestazione è corretta.
Le parole riservate sono parole che non possono esser usate né come nome di un programma, né come nome di una variabile, siccome sono istruzioni che dichiarano qualcosa. Alcune parole riservate sono:
Esempio:
Program end; <-------1° ERRORE var If:...; <-------2° ERRORE ...
In questo esempio vi sono 2 errori: ho usato END che è una parola riservata come nome del programma (END dichiara la fine del codice sorgente), ed ho usato IF che pure è una parola riservata come nome di una variabile (IF specifica una condizione).
Torna su é Una variabile è un contenitore all'interno del quale vi sono dei dati che possono variare durante l'esecuzione del programma. Le variabili in un programma scritto in Pascal sono dichiarate in una riga specifica dopo la parola VAR tramite dei nomi. Questi ultimi, detti anche identificatori, sono assegnati liberamente, ma non devono:
Se vi sono più variabili, i vari identificatori vengono separati da virgole (,). I dati contenuti nelle variabili possono essere di diverso tipo: testo, numeri interi, numeri reali ecc. Il tipo di una variabile deve essere indicato dopo l'identificatore, facendo seguire a quest'ultimo i due punti (:) e scrivendo il tipo della variabile. Se vi sono più variabili dello stesso tipo (ad esempio 3 numeri, 2 stringhe ecc.), si indicheranno i vari identificatori separati da virgole, si faranno seguire all'ultimo identificatore i due punti (:) e si scriverà il tipo delle variabili.
Esempio (dichiarazione di una variabile): ... var identificatore: tipo; ...
Esempio (dichiarazione di più variabili): ... var identificatore, ..., ..., identificatore: tipo; ...
Quando le variabili sono molteplici e di diverso tipo la sintassi è la seguante: ... var identificatore, ..., ..., identificatore: tipo1; var identificatore, ..., ..., identificatore: tipo2; ...
I principali tipi di variabili sono:
Quando si deve assegnare un valore ad una variabile (che è stata già dichiarata, altrimenti viene visualizzato un messaggio di errore), si segue la seguente sintassi: ... identificatore:=valore variabile; ...
Per esempio se la variabile è di tipo numerico e il suo identificatore è x si scriverà: ... x:=1234; ...
Invece se la variabile è di tipo testuale e il suo identificatore è y si scriverà: ... y:='parola'; ...
Gli apici (' ') identificano le variabili di tipo testuale STRING o CHAR.
Se in un programma non c'è bisogno di variabili la riga che le dichiara può anche essere omessa.
Torna su é Le costanti, al contrario delle variabili, sono contenitori di dati fissi. Esse non variano durante l'esecuzione del programma. In Pascal vengono elencate prima della riga delle variabili tramite la seguente sintassi: ... CONST nomecostante=valore; ...
Esempio - Struttura base di un programma che pone pigreco come costante:
Program areacerchio; intestazione
const pigreco=3.14;
riga
delle costanti ... corpo del programma ...
readln;
Se in un programma non c'è bisogno di costanti la riga che le dichiara può anche essere omessa.
Torna su é Le librerie sono un insieme di procedure e funzioni, racchiuse in un unico file, che potrebbero servire al programmatore per non ripetere un serie di istruzioni o per svolgere un'operazione che normalmente richiederebbe molto codice. La dichiarazione di una libreria non è obbligatoria, ma diventa indispensabile quando si vuole usare una procedure o una funzione presente nella libreria stessa. In Pascal le librerie sono chiamate UNIT e vengono eseguite creando un file con estensione .tpu. Le principali librerie sono:
-CRT -DOS -GRAPH -OVERLAY -PRINTER -SYSTEM
Per dichiarare un libreria, si scrive immediatamente sotto l'intestazione ... USES nomelibreria; ...
Se le librerie sono più di una vengono separate da una virgola. Esempio:
Program esempio; uses crt,graph; dichiarazione delle librerie CRT e GRAPH var a,x,y:integer; ...
La procedura CLRSCR Nella libreria CRT vi è una particolare procedura che nel codice sorgente di un programma può essere richiamata con CLRSCR (dall'ingl.: CLeaR SCReen = pulisci schermo). Questa procedura permette di eseguire un programma su schermo "pulito" da qualsiasi scritta relativa ad esecuzioni precedenti; è usata per avere una migliore visualizzazione di ciò che deve apparire a video. Il comando va inserito nel punto esatto del programma in cui si vuole che lo schermo sia "pulito" da ogni scritta (generalmente dopo il BEGIN) seguito da un punto e virgola obbligatorio. Quindi siccome si vuole utilizzare una procedura della libreria CRT, per il suo corretto funzionamento, è obbligatoria la riga USES CRT; per dichiarare la libreria stessa. Esempio:
Program esempio; uses CRT; dichiarazione della libreria CRT - è una riga OBBLIGATORIA begin CLRSCR; punto e virgola OBBLIGATORIO writeln('Un saluto a tutti i programmatori!'); readln; end.
Questo programma visualizza sullo schermo pulito da ulteriori scritte o testi relative ad esecuzioni precedenti, il messaggio "Un saluto a tutti i programmatori!". Il programma scritto senza il comando CLRSCR, avrebbe stampato a video lo stesso messaggio, ma con altri testi che lo precedevano (generalmente gli altri testi possono essere anche informazioni relative al compilatore; essi non influiscono sul programma corrente quindi anche se non si usa il comando CLRSCR il programma viene eseguito lo stesso, però non si ha una buona visualizzazione dei dati a video). Se CLRSCR fosse stato posto dopo la riga writeln in questo modo:
Program esempio; uses CRT; begin writeln('Un saluto a tutti i programmatori!'); CLRSCR; readln; end.
il compilatore prima avrebbe stampato a video il messaggio "Un saluto a tutti i programmatori!" e poi avrebbe pulito lo schermo; di conseguenza non avrebbe visualizzato niente. Quindi è importante determinare il punto esatto in cui inserire il comando CLRSCR.
Torna su é Il corpo del programma è la parte del programma stesso che contiene le tutte le istruzioni necessarie al funzionamento dell'algoritmo. Esso è compreso tra le righe BEGIN (dall'ingl.: inizio) e END (dall'ingl.: fine). In ogni programma possono anche esserci più BEGIN "chiusi" da un relativi END (questi casi saranno esaminati nei paragrafi successivi), infatti il numero dei BEGIN deve sempre corrispondere al numero degli END altrimenti al momento della compilazione si visualizzerà un messaggio di errore. Esempi:
Program n1; begin write('CIAO'); readln; end.
Program n2; begin write('CIAO'); readln; <-- ERRORE
Il programma n1 non fa altro che stampare a video, cioè scrivere sullo schermo, la scritta CIAO. La riga delle variabili (var ...) è stata omessa, in quanto non è serve alcuna variabile. Il corpo del programma è contenuto tra BEGIN ed END ed è costituito dalla sola riga: WRITE('CAIO');. Se il programma fosse stato scritto senza la riga end. (come l'esempio n2) all'esecuzione si sarebbe visualizzato un messaggio di errore, in quanto il numero dei BEGIN (1) non corrisponde col numero degli END (0).
I commenti spiegano il funzionamento di un programma. Per inserire un commento all'interno di un programma si può usare una delle 2 seguenti sintassi:
(*tra parentesi tonde e asterischi*) {tra parentesi graffe}
Esempio (con il programma precedente):
Program esempio; begin (*inizio del programma*) write('CIAO'); {riga che stampa CIAO} readln; end. {fine del programma}
Il compilatore eseguirà questo programma non leggendo le righe di commento, quindi i commenti non servono ai fini del linguaggio macchina, ma sono solo un aiuto al programmatore per comprendere meglio il codice sorgente, specialmente quando questo è costituito da numerose righe.
Torna su é Le istruzioni permettono al compilatore di eseguire determinate operazioni. Il linguaggio Pascal mette a disposizione del programmatore molteplici istruzioni per creare un programma. Una di queste è l'istruzione WRITE (dall'ingl.: scrivi), che è la più usata per comunicare con l'utente. Quest'istruzione permette di stampare a video, cioè di scrivere sullo schermo, qualsiasi scritta indicata fra gli apici (apostrofi). La sua sintassi è: ... WRITE('qui può essere inserito qualsiasi testo da stampare a video'); ...
Per esempio, se si vuole creare un programma che stampi a video la scritta "CIAO io sono un terrestre", si dovrà scrivere il seguente codice:
Program esempio; begin write('CIAO io sono un terreste'); readln; end.
Gli apici indicano l'inizio e la fine del testo da stampare a video. Se il testo tra gli apici contiene degli apostrofi (cioè altri apici), al momento dell'esecuzione verrà visualizzato un messaggio di errore, perché il compilatore non "capisce" dove è l'inizio e la fine del testo. Per rimediare a questo inconveniente, laddove c'è l'apostrofo, si usa il doppio apice (''). Ad esempio se si vuole stampare a video la scritta "Sull'isola che non c'è non c'è nessuno" il programma sarà (in rosso ho segnato i doppi apici):
Program esempio; begin write('Sull''isola che non c''è non c''è nessuno'); readln; end.
Per stampare a video una variabile gli apici non si mettono, seguendo questa sintassi: ... WRITE(nomedellavariabile); ...
Se di vuole visualizzare una variabile che è un numero reale l'istruzione WRITE stamperà a video la variabile in forma esponenziale; quindi si deve in qualche modo formattare l'output, cioè dare una forma più leggibile all'output stesso, specificando nell'istruzione WRITE il numero delle cifre decimali da visualizzare. Sintassi: ... WRITE(nomevariabile:0:numerocifredecimali); ...
Esempio: ... a:=13.567; b:=5465.6868; WRITE(a:0:2); WRITE(b:0:1); ...
La prima istruzione WRITE stamperà a video il numero a (13.567) arrotondato a 2 cifre decimali: 13.57. La seconda istruzione WRITE, invece, stamperà a video il numero b (5465.6868) arrotondato a 1 cifra decimale: 5465.7.
Per stampare a video una variabile e un testo nella stessa istruzione WRITE, la sintassi è la seguente: ... WRITE('Testo ',nomedellavariabile); ...
oppure:
... WRITE(nomedellavariabile,'Testo '); ...
Esempio riassuntivo:
Torna su é Un altra istruzione fondamentale per scrivere un programma in Pascal è READ (dall'ingl.: leggi). Mentre WRITE si occupa di comunicare con l'utente (il quale deve inserire o deve avere in output dei dati), READ serve per leggere i dati inseriti dall'utente assegnandoli alle variabili indicate. Sintassi: ... READ(nomevariabile); ...
Esempio:
Program esempio; var a:integer; begin write('Inserire un numero intero '); read(a); readln; end.
Nell'esempio l'istruzione WRITE si occupa di comunicare all'utente che deve inserire un numero intero, tramite il messaggio: Inserire un numero intero. L'istruzione READ, invece, attende l'inserimento del numero (da tastiera) e assegna il suo valore alla variabile a (precedentemente dichiarata nella riga delle variabili var a:integer).
L'istruzione READ usata senza parametri serve per aspettare che si prema un tasto per poi passare all'istruzione successiva. Sintassi: ... READ; ...
Il compilatore, infatti, giunto alla riga "READ;" aspetta che sia inserito un valore da tastiera, ma poi non avendo la variabile di destinazione in cui salvare il valore, passa all'operazione successiva.
Quando si devono inserire più dati si può ripetere l'istruzione READ per ogni dato: ... write('Inserire il primo numero '); read(a); write('Inserire il secondo numero '); read(b); write('Inserire il terzo numero'); read(c); ...
Per velocizzare quest'operazione e diminuire anche la lunghezza del codice sorgente, si può usare READ una sola volta: ... write('Inserire il primo, il secondo e il terzo numero '); read(a,b,c); ...
Si usa un solo READ separando con una virgola le tre variabili da leggere. Naturalmente, al momento dell'esecuzione, ogni numero deve essere seguito da un INVIO per essere letto. Al terzo numero inserito, e quindi al terzo INVIO, l'istruzione READ termina il suo compito e il compilatore passa ad eseguire le righe successive.
Torna su é Le istruzioni WRITELN e READLN Le istruzioni WRITELN e READLN (LN deriva dall'inglese line: linea) permettono di svolgere un'operazione su una nuova riga, cioè spostano il cursore all'inizio della riga successiva ed eseguono l'operazione. Le sintassi sono: ... WRITELN('testo da stampare'); ... READLN(nomevariabile); ...
L'istruzione WRITELN permette di scrivere da capo il testo inserito negli apici. Quest'ultima usata senza testo tra apici, in questo modo: ... WRITELN; ... permette di inserire un'interlinea vuota.
L'istruzione READLN permette la lettura di una variabile in una nuova riga.
Esempio riassuntivo:
Program somma;
var a,b,c:integer; a:=3; {assegna 3 alla variabile a} write(a); {stampa a video il valore di a (3)} b:=4; {assegna 4 alla variabile b} write(' ',b); {stampa a video uno spazio e il valore di b (4)}
c:=a+b;
{assegna la somma di
a e b
alla variabile c}
readln; {
e
il valore di c (7)}
Questo programma stampa a video:
3 4 Somma=7 Come si vede il risultato è poco leggibile. Utilizzando WRITELN e modificando leggermente le stringhe fra gli apici si avrà:
Program somma;
var a,b,c:integer; a:=3; {assegna 3 alla variabile a} writeln('a = ',a); {stampa a video il valore di a (3)} b:=4; {assegna 4 alla variabile b} writeln('b = ',b); {stampa a video uno spazio e il valore di b (4)} c:=a+b; {assegna la somma di a e b alla variabile c}
writeln;
{riga vuota}
readln;
{ e
il valore di c (7)}
Questo nuovo programma stamperà a video, in modo più leggibile:
a = 3
Torna su é Un algoritmo è un insieme finito di istruzioni che servono a specificare una serie di operazioni con le quali è possibile risolvere un problema. Un programma in Pascal quindi, come in qualsiasi altro linguaggio di programmazione, rappresenta un algoritmo. Secondo il teorema di Böhm-Jacopini (del 1966): "Un qualsiasi algoritmo può essere espresso usando esclusivamente le strutture di sequenza, di selezione e di iterazione". Questi 3 modelli si chiamano strutture di controllo.
La struttura dei programmi finora esaminati è la sequenza, cioè le istruzioni vengono eseguite una dopo l'altra:
Program esempio; ... begin ... ISTRUZIONE1; ISTRUZIONE2; ISTRUZIONE3; ... readln; end.
La struttura di selezione, o alternativa, in Pascal viene rappresentata secondo lo schema: ... IF condizione THEN istruzione1 ELSE istruzione2; ...
Se la condizione è vera viene eseguita l'istruzione1, altrimenti (cioè se la condizione è falsa) viene eseguita l'istruzione2.
La struttura di iterazione, o di ripetizione, consiste in un ciclo con una condizione alla fine (iterazione postcondizionale) o all'inizio (iterazione precondizionale).
Se il ciclo è postcondizionale la codifica in Pascal è: ... REPEAT ... istruzioni; ... UNTIL condizione; ...
Le istruzioni, o l'istruzione, tra Repeat e Until verranno ripetute fino a quando la condizione diventa vera; quindi la struttura cicla (cioè si ripete) per falso.
Se il ciclo è precondizionale la codifica in Pascal è: ... WHILE condizione DO BEGIN ... istruzioni; ... END; ...
Le istruzioni tra Begin ed End verranno ripetute fino a quando la condizione diventa falsa; quindi la struttura cicla (cioè si ripete) per vero. Se c'è una sola istruzione da ripetere, il BEGIN e l'END possono essere omessi.
Esiste una struttura di ripetizione senza una vera e propria condizione, chiamata ripetizione con contatore o enumerativa. La sua codifica in Pascal è: ... FOR contatore:=valoreiniziale TO valorefinale DO BEGIN ... istruzioni; ... END; ...
Le istruzioni tra Begin ed End verranno ripetute tante volte quante ne occorrono per portare il valore del contatore dal valore iniziale al valore finale (ES. FOR C:=1 TO 15 DO, per portare il contatore C da 1 a 15 c'è bisogno di 15 passaggi, quindi le operazioni verranno eseguite 15 volte). Se c'è una sola istruzione da ripetere, il BEGIN e l'END possono essere omessi.
Torna su é La struttura di selezione, o alternativa, in Pascal viene codificata con le istruzioni IF...THEN...ELSE (dall'ingl.: se...allora...altrimenti): ... IF condizione THEN istruzione1 <-- senza punto e virgola ELSE istruzione2; ...
Cioè: se la condizione espressa dopo IF sarà vera, il programma eseguirà l'istruzione1, altrimenti (cioè se la condizione sarà falsa) eseguirà l'istruzione2 introdotta da ELSE. Se il programma eseguirà l'istruzione1, automaticamente l'istruzione2 non verrà eseguita, e viceversa. E' molto importante non mettere il punto e virgola prima della riga dell'ELSE, altrimenti al momento dell'esecuzione si visualizzerà un messaggio di errore. Quando non si deve eseguire alcuna operazione nel caso in cui la condizione risulti falsa, la riga dell'ELSE può essere esclusa: ... IF condizione THEN istruzione; <-- con punto e virgola ... Cioè: se la condizione espressa dopo IF sarà vera, il programma eseguirà l'istruzione1, altrimenti (cioè se la condizione sarà falsa) passerà alle istruzioni successive.
Esempio di programma con l'istruzione IF...THEN...ELSE:
Program esempio;
readln; Questo programma, richiede l'inserimento di 2 numeri; poi verifica la condizione (a>b); se essa è vera (cioè se a è maggiore di b) stampa a video "Il primo numero è maggiore del secondo", altrimenti, se è falsa (cioè se a non è maggiore di b) stampa a video "Il secondo numero è maggiore del primo". Se i numeri inseriti sono uguali verrà stampato a video "Secondo numero maggiore del primo". Questo inaspettato comportamento del compilatore è normale; infatti, se la condizione è falsa il compilatore esegue l'istruzione introdotta da ELSE senza verificare un'ulteriore condizione (che in questo caso sarebbe a=b). Ad esempio, se i 2 numeri fossero 33 e 33, il compilatore verificherebbe la condizione a>b, che in questo è falsa perché 33 non è maggiore di 33, allora eseguirebbe l'istruzione introdotta da ELSE stampando a video "Il secondo numero è maggiore del primo". Il programma completo sarebbe:
Program esempio; if a=b then writeln('I numeri sono uguali') {ulteriore condizione} else writeln('Il secondo numero è maggiore del primo');
readln;
Esempio con variabile di tipo STRING:
Program esempio; Una variabile di tipo STRING è testuale. In questo caso lo è la variabile a. Questo programma, dopo aver letto la variabile a (inserita da tastiera rispondendo alla domanda "Sei maschio?" con si o qualche altra scritta), verifica la condizione (a='si'); se essa è vera (cioè se a è uguale a si con le lettere minuscole), stampa a video "INDIVIDUO MASCHILE", altrimenti, se è falsa (cioè se a è uguale a qualsiasi altra scritta), stampa a video "INDIVIDUO FEMMINILE".
Quando nell'istruzione IF...THEN...ELSE le parole THEN e ELSE introducono più operazioni, queste vengono racchiuse tra un altro BEGIN e un altro END; in modo da organizzare meglio l'esecuzione del programma; a volte, infatti, il malfunzionamento del programma dipende proprio da questo fattore. Esempio:
Program esempio; Questo programma dopo aver letto le due variabili inserite da tastiera (a e b), verifica la condizione (a=b); se essa è vera esegue la moltiplicazione dei numeri (c:=a*b) e stampa a video il messaggio "Numeri UGUALI - Prodotto=prodottodeinumeri"; se essa è falsa esegue la somma dei numeri e stampa a video il messaggio "Numeri DIVERSI - Somma=sommadeinumeri". Il primo END (10ª riga) non deve finire né con un punto (perché non è lì che termina il programma), né con un punto e virgola, perché dopo di esso vi è l'istruzione ELSE che non deve essere mai preceduta da un punto e virgola.
L'istruzione IF...THEN...ELSE permette solo una doppia selezione, cioè solo 2 scelte: vero o falso. Per la scelta multipla si usa la struttura CASE...OF spiegata di seguito.
Torna su é Nel linguaggio Pascal le condizioni che vengono specificate possono essere raggruppate per congiunzione o disgiunzione, oppure possono essere negate (considerate al contrario di quello che effettivamente sono). In pratica il linguaggio Pascal permette di specificare più condizioni correlate tra loro tramite delle parole riservate che sono:
Esempio1: creare un programma che verifichi se un numero inserito da tastiera è compreso tra 100 e 1000, tramite l'uso dell'operatore logico AND.
Program esempio1; uses CRT; var a:integer; begin clrscr; write('Inserisci un numero: '); readln(a); if (a>=100) AND (a<=1000) then writeln('Il numero è compreso tra 100 e 1000') else writeln('Il numero non è compreso tra 100 e 1000'); readln; end.
Questo programma dopo aver ricevuto da tastiera un numero (a) verifica se è maggiore o uguale a 100 (a>=100) E se è minore o uguale a 1000 (a<=1000). Se entrambi i confronti risultano veri allora tutta la condizione sarà vera e si visualizzerà il messaggio "Il numero è compreso tra 100 e 1000". Se uno solo dei due confronti o entrambi risultano falsi tutta la condizione sarà falsa e si visualizzerà il messaggio "Il numero non è compreso tra 100 e 1000". Se l'utente inserisce ad esempio il numero 1888, il programma verifica il primo confronto a>=100 che risulta vero, poi verifica il secondo confronto a<=1000 che risulta falso; come si nota uno dei due confronti è falso e quindi tutta la condizione risulterà falsa, di conseguenza si visualizzerà il messaggio "Il numero non è compreso tra 100 e 1000".
Esempio2: creare un programma che verifichi se un numero inserito da tastiera è uguale a 126 oppure a 2593, tramite l'uso dell'operatore logico OR.
Program esempio2; uses CRT; var a:integer; begin clrscr; write('Inserisci un numero: '); readln(a); if (a=126) OR (a=2593) then writeln('Il numero inserito è 126 oppure 2593') else writeln('Il numero inserito non è nè 126 nè 2593'); readln; end.
Questo programma dopo aver ricevuto da tastiera un numero (a) verifica se è uguale a 126 (a=126) O se è uguale a 2593 (a=2593). Se uno dei confronti risulta vero allora tutta la condizione sarà vera e si visualizzerà il messaggio "Il numero inserito è 126 oppure 2593". Se entrambi i confronti risultano falsi tutta la condizione sarà falsa e si visualizzerà il messaggio "Il numero inserito non è nè 126 nè 2593". Se l'utente inserisce ad esempio il numero 126, il programma verifica il primo confronto a=126 che risulta vero, poi verifica il secondo confronto a=2593 che risulta falso; come si nota uno dei due confronti è vero e quindi tutta la condizione risulterà vera, di conseguenza si visualizzerà il messaggio "Il numero inserito è 126 oppure 2593".
Esempio3: creare un programma che verifichi se un numero inserito da tastiera è uguale a 999, tramite l'uso dell'operatore logico NOT.
Program esempio3; uses CRT; var a:integer; begin clrscr; write('Inserisci un numero: '); readln(a); if NOT(a<>999) then writeln('Il numero inserito è 999') else writeln('Il numero inserito non è 999'); readln; end.
Questo programma dopo aver ricevuto da tastiera un numero (a) verifica se NON è diverso da 999 (NOT(a<>999)). Se a NON è diverso da 999 significa che è uguale a 999, allora si visualizzerà il messaggio "Il numero inserito è 999". Se la condizione è ancora negativa, cioè se a NON (NON è diverso da 999) significa che è effettivamente diverso da 999, allora si visualizzerà il messaggio "Il numero inserito non è 999". Si tenga presente che l'operatore NOT viene usato generalmente con le variabili booleane in programmi più complessi.
Esiste anche un quarto operatore logico che raramente viene usato: XOR (disgiunzione esclusiva). Esempio: ... if (a>10) XOR (b>10) then istruzione1 else istruzione2; ...
Tutta la condizione ((a>10) XOR (b>10)) risulterà vera se i confronti saranno diversi tra di loro (cioè se il primo sarà vero e il secondo falso, oppure se il primo sarà falso e il secondo vero); se entrambi i confronti risulteranno uguali tutta la condizione sarà falsa (cioè se entrambi saranno veri o entrambi saranno falsi).
In conclusione, le tabelle seguente descrivono il funzionamento dei quattro operatori esaminati considerando che z e k siano due confronti:
Torna su é La struttura di selezione con CASE...OF La struttura di selezione con CASE...OF (dall'ingl.: caso...di) permette di effettuare una selezione multipla. La sua sintassi è: ... CASE variabile OF <-- senza punto e virgola verifica1: istruzione1; verifica2: istruzione2; ... else operazioneN; end; ...
Cioè: nel caso in cui la variabile (...CASE variabile OF...) sia uguale alla verifica1, il compilatore esegue l'istruzione1; nel caso in cui la variabile sia uguale alla verifica2, il compilatore esegue l'istruzione2, e così via, fino all'ultima verifica. Se nessuna delle condizioni è verificata, il compilatore esegue l'operazioneN introdotta da ELSE (dall'ingl.: altrimenti). Se si verifica una condizione, automaticamente le altre non verranno verificate. L'istruzione END; è obbligatoria anche se non esiste un BEGIN vero e proprio. La prima riga della struttura non deve terminare con il punto e virgola.
Esempio di programma con CASE...OF:
Program esempio;
0:writeln('ZERO');
4:writeln('QUATTRO');
readln; Questo programma stampa a video il messaggio "Scrivi un numero" e dopo aver letto il numero (inserito da tastiera), lo assegna alla variabile n. Poi verifica se la variabile n (cioè il numero), è uguale a 0, 1, 2, 3 o 4; se è uguale a 0 stampa a video la scritta "ZERO"; se è uguale a 1 stampa a video la scritta "UNO"; se è uguale a 2 stampa a video la scritta "DUE"; se è uguale a 3 stampa e video la scritta "TRE" e se è uguale a 4 stampa a video la scritta "QUATTRO". Se il numero inserito non è né 0, né 1, né 2, né 3 e né 4, stampa a video ciò che è introdotto da ELSE, cioè la scritta "Errore". Scrivere questo programma con IF...THEN...ELSE sarebbe stato più complesso:
Program esempio;
Quando le istruzioni da eseguire dopo le verifiche sono più di una, si crea un sottoprogramma con un altro BEGIN e un altro END, con la seguente sintassi:
... CASE variabile OF <-- senza punto e virgola verifica1: begin <-- senza punto e virgola ... istruzioni; ... end; verifica2: begin <-- senza punto e virgola ... istruzioni; ... end; ... else operazioneN; end; ...
Esempio di programma con più operazioni da eseguire dopo le verifiche, usando l'istruzione CASE...OF:
Program esempio;
uses CRT;
clrscr;
writeln; Questo programma, prima di tutto "pulisce lo schermo" (CLRSCR), poi stampa a video il messaggio:
1 - somma
Che operazione devi svolgere? (1/2)
Avvisando l'utente che potrà inserire soltanto i numeri 1 o 2 (1 per svolgere la somma, 2 per svolgere la differenza). Ricevuto il numero inserito da tastiera (readln(a);), passa alle verifiche. Se il numero è uguale 1, stampa a video la scritta "Scrivi i due numeri'", legge i due numeri inseriti (readln(b,c);), lascia una riga vuota (writeln;) e stampa a video la loro somma (writeln(b+c);). Se il numero è uguale 2, stampa a video la scritta "Scrivi i due numeri'", legge i due numeri inseriti (readln(d,e);), lascia una riga vuota (writeln;) e stampa a video la loro differenza(writeln(d-e);). Infine se il numero inserito non è né 1, né 2, stampa a video ciò che è introdotto da ELSE, cioè la scritta "NUMERO NON VALIDO". _____________________________
Con la struttura CASE...OF potrebbero sorgere dei problemi quando le verifiche rappresentano degli intervalli; questi ultimi si rappresentano con questa sintassi: ... CASE variabile OF <-- senza punto e virgola estremosinitro1 .. estremodestro1: istruzione1; estremosinitro2 .. estremodestro2: istruzione2; ... else operazioneN; end; ...
Esempio: creare un programma che, inserito un numero da tastiera, verifichi e stampi a video se questo si trova tra 0 e 50, tra 51 e 100, tra 101 e 150 oppure tra 151 e 200.
Program esempioERRATO; uses CRT; var a:integer; begin clrscr; write('Inserisci un numero: '); readln(a); CASE a OF <50:writeln('Numero compreso tra 0 e 50'); >50 and <100:writeln('Numero compreso tra 51 e 100'); >100 and <150:writeln('Numero compreso tra 101 e 150'); >150 and <200:writeln('Numero compreso tra 151 e 200'); else writeln('Numero maggiore di 200'); end; readln; end.
Questo programma esempio è errato. In rosso sono segnati gli errori, cioè l'errata impostazione degli intervalli. Il programma corretto, riscritto secondo la sintassi esatta è questo:
Program esempiointervalli; uses CRT; var a:integer; begin clrscr; write('Inserisci un numero: '); readln(a); CASE a OF 0..50:writeln('Numero compreso tra 0 e 50'); 51..100:writeln('Numero compreso tra 51 e 100'); 101..150:writeln('Numero compreso tra 101 e 150'); 151..200:writeln('Numero compreso tra 151 e 200'); else writeln('Numero maggiore di 200'); end; readln; end.
Torna su é La struttura di iterazione, o di ripetizione, con ciclo postcondizionale, in Pascal viene codificata con le istruzioni REPEAT...UNTIL (dall'ingl.: ripeti...fino) che ha la seguente sintassi: ... REPEAT <-- senza punto e virgola ... istruzioni; ... UNTIL condizione; ...
Le istruzioni, o l'istruzione, tra Repeat e Until verranno ripetute fino a quando la condizione diventa vera; quindi la struttura cicla (cioè si ripete) per falso. Quando la condizione sarà vera, il compilatore uscirà dal ciclo e passerà ad eseguire le operazioni successive (cioè quelle dopo la riga "UNTIL condizione;"). Se la condizione indicata dopo UNTIL fosse sempre falsa il compilatore non uscirebbe mai dal ciclo e, al momento dell'esecuzione, provocherebbe una ripetizione all'infinito delle istruzioni comprese tra repeat e until. In questi casi si dice che il computer si blocca o si impianta. Per risolvere questo problema si deve spegnere la macchina o chiudere il compilatore e riscrivere il programma da capo. Visto questo inconveniente, se il programma scritto è di una certa lunghezza e complessità, è bene salvare il codice sorgente prima di eseguirlo.
Esempio di programma che si impianta:
Esempio di programma scritto usando il ciclo REPEAT...UNTIL:
Program esempio;
writeln('Somma
totale = ',t);
Dopo aver inserito un numero: - Premi INVIO per inserirne un'altro - Premi 0 per terminare
Inserisci un numero
Prima di stampare a video "Inserisci un numero", il compilatore azzera la variabile t. Quando il compilatore stampa a video il messaggio "Inserisci un numero", entra nel ciclo. Dopo aver letto il numero inserito da tastiera ed averlo immagazzinato nella variabile n (readln(n);), il compilatore esegue la somma tra il numero inserito e la variabile t (che la prima volta è uguale a 0), assegnandola sempre alla variabile t; poi verifica la condizione specificata da Until n=0, la quale indica che fino a quando il numero inserito (n) sarà diverso da zero, si ripeteranno le operazioni comprese tra il REPEAT e l'UNTIL. Se la condizione è falsa (cioè, se n è diverso da 0) il compilatore ritorna ad eseguire il programma dall'istruzione REPEAT (leggendo un altro numero e sommando lo stesso alla somma precedente, cioè a t). Se la condizione è vera (cioè, se n è uguale a 0, in quanto l'utente ha deciso di "terminare" inserendo 0), esce dal ciclo ed esegue le istruzioni successive, cioè stampa a video "Somma totale = valoredellavariabilet", e termina l'esecuzione del programma. La variabile t è detta variabile di accumulamento, perché serve ad accumulare la somma dei vari numeri man mano che si inseriscono.
Per altri programmi col ciclo REPEAT...UNTIL visita la pagina PROGRAMMI.
Torna su é La struttura di iterazione, o di ripetizione, con ciclo precondizionale, in Pascal viene codificata con le istruzioni WHILE...DO (dall'ingl.: mentre...fai) che ha la seguente sintassi: ... WHILE condizione DO <-- senza punto e virgola BEGIN <-- senza punto e virgola ... istruzioni; ... END; ...
Quando la condizione sarà falsa, il compilatore uscirà da ciclo e passerà ad eseguire le istruzioni successive (cioè quelle dopo la riga "END;").
Esempio di programma con WHILE...DO:
Program esempio; Questo programma stampa a video il messaggio "Scrivi due numeri" e dopo averli letti passa a verificare la condizione (a>b). Se la condizione sarà vera (cioè se il primo numero inserito è maggiore del secondo), eseguirà l'operazione stabilita (a:=a-10) assegnando ad a, cioè al numero maggiore, il decremento di quest'ultimo di 10 unità. Terminata quest'operazione, il compilatore ritorna a verificare la condizione. Il ciclo continua fino a quando la condizione si verifica vera; quando si verificherà falsa (cioè quando b, il secondo numero, diventerà maggiore di a), il compilatore uscirà dal ciclo ed eseguirà le operazioni successive, cioè stamperà a video il messaggio: "Numero finale valoredellavariabilea", e terminerà l'esecuzione del programma.
Se la condizione indicata tra WHILE e DO fosse sempre vera il compilatore non uscirebbe mai dal ciclo e, al momento dell'esecuzione, provocherebbe una ripetizione all'infinito dell'operazione specificata tra il begin e l'end. In questi casi si dice che il computer si blocca o si impianta. Per risolvere questo problema si deve spegnere la macchina o chiudere il compilatore e riscrivere il programma da capo. Visto questo inconveniente, se il programma scritto è di una certa lunghezza e complessità, è bene salvare il codice sorgente prima di eseguirlo.
Esempio di programma che si impianta:
Program esempio;
begin end;
writeln('Somma
totale = ',t);
Questo programma si impianta e chiede all'infinito l'inserimento di un numero, perché la variabile specificata nella condizione (c) non viene mai aggiornata nel ciclo, ed essendo, quindi, sempre uguale a 0 (come specificato alla riga n° 4), fa sì che la condizione (c<3) sia sempre vera e il compilatore non esca mai dal ciclo.
Per altri programmi col ciclo WHILE...DO visita la pagina PROGRAMMI.
Torna su é La struttura di ripetizione con contatore o enumerativa, in Pascal viene codificata con le istruzioni FOR...TO...DO (dall'ingl.: per...a...fai), che ha la seguente sintassi: ... FOR contatore:=valoreiniziale TO valorefinale DO <-- senza punto e virgola BEGIN <-- senza punto e virgola ... istruzioni; ... END; ...
Le istruzioni tra Begin ed End verranno ripetute tante volte quante ne occorrono per portare il valore del contatore dal valore iniziale al valore finale (ES. FOR C:=1 TO 15 DO, per portare il contatore C da 1 a 15 c'è bisogno di 15 passaggi, quindi le operazioni verranno eseguite 15 volte). Se c'è una sola istruzione da ripetere, il BEGIN e l'END possono essere omessi. È molto importante non chiudere la prima riga del ciclo con il punto e virgola (;), altrimenti si interromperebbe il ciclo e il compilatore, al momento dell'esecuzione, visualizzerebbe un messaggio d'errore.
Esempio di programma con FOR...TO...DO:
Program esempio;
readln; Il programma può essere scritto anche nel seguente modo:
Program esempio; b:=1;
c:=20;
readln; Quando si devono ripetere più di un'operazione si usano strutture simili alla seguente:
Program esempio;
uses CRT; clrscr;
b:=0;
writeln(a); writeln('La somma dei numeri da 1 a 5 è ',b);
readln; Questo programma esegue la somma dei numeri da 1 a 5, e li stampa a video uno sotto l'altro. Alla 5ª riga viene pulito lo schermo; alla 7ª riga viene dichiarato l'inizio del ciclo; alla 9ª e alla 10ª riga vengono eseguite le operazioni del ciclo: stampa a video del numero (writeln(a);) e somma dei vari numeri (b:=b+a;), in questo caso b è una variabile di accumulamento. Dopo la ripetizione per 5 volte, il compilatore esce dal ciclo ed esegue l'istruzione alla 12ª riga (writeln('La somma dei numeri da 1 a 5 è ',b);), e aspetta la pressione di un tasto (readln;) per poi terminare.
E' anche possibile far procedere il ciclo FOR...TO...DO all'inverso, cioè dal valore finale al valore iniziale. La sintassi è la seguente: ... FOR contatore:=valorefinale DOWNTO valoreiniziale DO <-- senza punto e virgola BEGIN <-- senza punto e virgola ... istruzioni; ... END; ...
Il primo esempio col ciclo FOR...TO...DO può essere così riscritto:
Program esempio;
readln;
Il programma precedente stampava a video, uno sotto l'altro, i numeri da 1 a 20. Adesso questo programma col ciclo FOR...DOWNTO...DO stampa a video, uno sotto l'altro, i numeri da 20 a 1.
Per altri programmi col ciclo FOR...TO...DO visita la pagina PROGRAMMI.
Torna su é Grafica in ambiente TURBO Pascal 3.0 In TURBO Pascal 3.0 esistono 2 diverse modalità per l'uso dello schermo: modalità testuale e modalità grafica.
Per la modalità testuale lo schermo è suddiviso in 80x25 pixel (il pixel è la minima unità grafica di uno schermo; dall'ingl.: PIcture X ELement). In questa risoluzione grafica vengono visualizzati i caratteri. La posizione del cursore (come ogni pixel) è individuata da due coordinate: ascissa (x) e ordinata (y), con origine degli assi posto in alto a sinistra nello schermo. Per spostare il cursore nella posizione desiderata si usa la seguente istruzione: ... GOTOXY(ascissa,ordinata); ...
Ad esempio per scrivere il messaggio "CIAO", nel punto dello schermo di ascissa 60 e ordinata 5, il programma da scrivere è il seguente:
Program esempio; writeln('CIAO');
readln; La riga delle variabili è assente perché non c'è bisogno di alcuna variabile.
Per la modalità grafica lo schermo può essere utilizzato a bassa o ad alta risoluzione. A bassa risoluzione lo schermo è suddiviso in 320x200 pixel, ognuno individuato da due coordinate, x e y di tipo INTEGER. Per impostare la bassa risoluzione si usa il comando GRAPHCOLORMODE (dall'ingl: modalità grafica a colori).
Per stampare a video un punto, si usa l'istruzione: ... PLOT(x,y,c) ...
Dove x è l'ascissa, y è l'ordinata e c è il colore del punto. Il colore può assumere i seguenti valori:
Esempio - Programma che stampa a video un punto di coordinate 40 (ascissa) e 23 (ordinata), di colore arancione, con l'istruzione PLOT:
Program esempio; plot(40,23,3); {riga dell'istruzione PLOT}
readln; La riga delle variabili è assente perché non c'è bisogno di alcuna variabile.
Per stampare a video un segmento, si usa l'istruzione: ... DRAW(x1,y1,x2,y2,c); ...
Dove x1 è l'ascissa del primo punto, y1 è l'ordinata del primo punto, x2 è l'ascissa del secondo punto, y2 è l'ordinata del secondo punto e c è il colore del segmento, che può assumere i valori sopradescritti. L'istruzione DRAW non fa altro che trovare il primo e il secondo punto (tramite le coordinate scritte tra le parentesi dell'istruzione) e unirli con altri punti intermedi agli stessi, creando in questo modo un segmento.
Esempio - Programma che stampa a video un segmento che va dal punto di ascissa 10 e ordinata 19, al punto di ascissa 80 e ordinata 100, di colore rosso, con l'istruzione DRAW:
Program esempio;
readln;
Per stampare a video un segmento, orizzontale o verticale, si può anche utilizzare il ciclo FOR...TO...DO insieme all'istruzione PLOT, in questo modo: ... FOR x o y:=valoreiniziale TO valorefinale DO senza punto e virgola PLOT(x,y,c); ...
Se la variabile del ciclo FOR...TO...DO è x nell'istruzione PLOT si dovrà scrivere: PLOT(x,numero,c); dove numero di ordinata è un numero scelto dall'utente e la linea verrà orizzontale.
Se la variabile del ciclo FOR...TO...DO è y nell'istruzione PLOT si dovrà scrivere: PLOT(numero,y,c); dove numero di ascissa è un numero scelto dall'utente, e la linea verrà verticale.
Valoreiniziale e valorefinale dovranno essere i limiti di punti da stampare a video. Esempio: ... FOR y:=0 TO 100 DO ...
indica che la linea sarà verticale e formata da 100 punti.
Esempio - Programma che stampa a video un segmento orizzontale, di colore verde, con il ciclo FOR...TO...DO insieme all'istruzione PLOT, (i punti del segmento avranno la y uguale a 8):
Program esempio;
readln; Esempio - Programma che stampa a video un segmento verticale, di colore arancione, con il ciclo FOR...TO...DO insieme all'istruzione PLOT, (i punti del segmento avranno la x uguale a 8):
Program esempio;
readln;
Per impostare l'alta risoluzione si usa il comando HIRES (delle parole inglesi HIgh (alta) RESolution (risoluzione)). Ad alta risoluzione lo schermo è suddiviso in 640x200 pixel. L'ambiente grafico ad alta risoluzione permette di utilizzare solo il nero come colore di sfondo e solo un colore grafico. Sintassi per impostare l'alta risoluzione: ... HIRES; impostazione della modalità grafica ad ALTA risoluzione HIRESCOLOR(c); dichiarazione del colore grafico ...
Dove c, che può assumere i valori sopradescritti, è il colore con il quale sarà disegnata la grafica (punti e segmenti).
Per quanto riguarda le istruzioni di stampa a video di punti o segmenti, le sintassi sono le stesse.
Esempio - Programma che stampa a video un punto e un segmento verticale di colore verde con la modalità grafica ad alta risoluzione:
Program esempio;
In TURBO Pascal 7.0, invece, esistono altre funzioni grafiche molto più avanzate. Ciò non vieta però di usare le funzioni del TURBO Pascal 3.0. Di seguito vi sono 2 brevi esempi:
1) Grafica in Pascal 3.0 applicata in ambiente Pascal 7.0:
Program esempiografica; uses graph3; {dichiarazione della libreria GRAPH3}
var x:integer; readln; end.
Si noti l'uso della libreria GRAPH3 specifica per la grafica in Pascal 3.0.
2) Grafica in Pascal 7.0:
Program esempiografica; Si noti l'uso della libreria GRAPH specifica per la grafica in Pascal 7.0, e le numerose nuove istruzioni e funzioni come DETECT che richiama il driver grafico, INITGRAPH che inizializza le modalità grafica, GRAPHRESULT che ricerca eventuali errori nelle ultime operazioni grafiche, GROK che rappresenta gli errori, HALT che permette di uscire forzatamente cioè senza arrivare all'END, CIRCLE che disegna un cerchio specificando le coordinate del centro e la misura del raggio ed infine CLOSEGRAPH che permette di uscire dalla modalità grafica.
Per maggiori informazioni sulla grafica in ambiente 7.0 vedere il paragrafo specifico nella guida avanzata.
Torna su é Nel linguaggio Pascal esistono delle funzioni particolari che permettono di eseguire determinati calcoli. Di seguito sono elencate alcune di queste funzioni, con le relative spiegazioni ed esempi.
________1________
SQRT(variabile) - Calcola la radice quadrata della variabile specificata tra parentesi. Es.: a:=SQRT(144). La variabile a sarà uguale a 12.
Esempio1:
Program esempio; Esempio2:
Program esempio; var a:real; begin a:=sqrt(36); writeln('La radice di 36 è ',a:0:1); readln; end.
________2________
SQR(variabile) - Calcola il quadrato della variabile specificata tra parentesi. Es.: b:=SQR(23). La variabile b sarà uguale a 529.
Esempio1:
Program esempio; var a,b:integer; begin writeln('Inserisci il numero di cui vuoi calcolare il quadrato'); readln(a); b:=sqr(a); writeln('Il quadrato di ',a,' è ',b); readln; end.
Esempio2:
Program esempio; var a:integer; begin a:=sqr(53); writeln('Il quadrato di 53 è ',a); readln; end.
________3________
INT(variabile) - Fornisce la parte intera della variabile specificata tra parentesi. Es.: c:=int(23.45). La variabile c sarà uguale a 23.
Esempio1:
Program esempio; var a,b:real; begin writeln('Inserisci il numero di cui vuoi visualizzare la parte intera'); readln(a); b:=int(a); writeln('La parte intera di ',a:0:5,' è ',b:0:0); readln; end.
Esempio2:
Program esempio; var a:real; begin a:=int(78.129); writeln('La parte intera di 78.129 è ',a:0:0); readln; end.
________4________
TRUNC(variabile) - Tronca la parte decimale della variabile specificata tra parentesi. Es.: d:=TRUNC(3.32). La variabile d sarà uguale a 3. Questa funzione è pressoché uguale alla funzione INT.
Esempio1:
Program esempio; var a,b:real; begin writeln('Inserisci il numero di cui vuoi troncare la parte decimale'); readln(a); b:=trunc(a); writeln('La parte intera di ',a:0:5,' è ',b:0:0); readln; end.
Esempio2:
Program esempio; var a:real; begin a:=trunc(45.4935); writeln('La parte intera di 45.4935 è ',a:0:0); readln; end.
________5________
FRAC(variabile) - Fornisce la parte decimale della variabile specificata tra parentesi. Es.: e:=FRAC(3.32). La variabile e sarà uguale a 0.32.
Esempio1:
Program esempio; var a,b:real; begin writeln('Inserisci il numero di cui vuoi visualizzare la parte decimale''); readln(a); b:=frac(a); writeln('La parte decimale di ',a:0:5,' è ',b:0:5); readln; end.
Esempio2:
Program esempio; var a:real; begin a:=frac(4166.455); writeln('La parte decimale di 4166.455 è ',a:0:5); readln; end.
________6________
ROUND(variabile) - Arrotonda il valore della variabile specificata tra parentesi all'intero più vicino. Es.: f:=ROUND(3.8). La variabile f sarà uguale a 4.
Esempio1:
Program esempio; var a,b:real; begin writeln('Quale numero vuoi arrotondare?'); readln(a); b:=round(a); writeln('Il numero arrotondato è ',b:0:0); readln; end.
Esempio2:
Program esempio; var a:real; begin a:=round(318.2); writeln('Il numero arrotondato è ',a:0:0); readln; end.
________7________
ABS(variabile) - Calcola il valore assoluto della variabile specificata tra parentesi. Es.: g:=ABS(-10). La variabile g sarà uguale a 10.
Esempio1:
Program esempio; var a,b:real; begin writeln('Inserisci il numero di cui vuoi visualizzare il valore assoluto'); readln(a); b:=abs(a); writeln('Il valore assoluto di ',a:0:0,' è ',b:0:0); readln; end.
Esempio2:
Program esempio; var a:real; begin a:=abs(-15); writeln('Il valore assoluto di -15 è ',a:0:0); readln; end.
________8_________
variabile1 MOD variabile2 - Calcola il resto della divisione tra la variabile1 e la variabile2. Es.: h:=16 MOD 5. La variabile h sarà uguale a 1.
Esempio1:
Program esempio; Esempio2:
Program esempio; var a:integer; begin a:=10 mod 3; writeln('Il resto della divisione è ',a); readln; end.
________9________
variabile1 DIV variabile2 - Calcola la parte intera del quoziente tra la variabile1 e la variabile2. Es.: i:=11 div 5. La variabile i sarà uguale a 2.
Esempio1:
Program esempio;
Esempio2:
Program esempio; var a:integer; begin a:=10 div 3; writeln('Il quoziente intero della divisione è ',a); readln; end.
________10________
RANDOM(variabile) - Genera numeri a caso compresi fra 0 e la variabile specificata tra parentesi (numero-limite). Es.: n:=RANDOM(50) calcolerà, ad ogni esecuzione, un numero casuale compreso tra 0 e 50, assegnandolo alla variabile n. L'istruzione RANDOMIZE serve per azzerare il generatore di numeri casuali; è obbligatoria.
Esempio1:
Program esempio;
randomize; Esempio2:
Program esempio; var a:integer; begin randomize; a:=random(90); writeln('Numero casuale compreso tra 0 e 90 :',a); readln; end.
________11________
CHR(codiceASCIIdelcarattere) - Restituisce il carattere ASCII con codice specificato tra parentesi. Es.: k:=chr(110). La variabile k restituirà la lettera "n" che ha 110 come codice nella tabella ASCII.
Esempio1:
Program carattere;
b:integer;
b:=67;
Esempio2:
Program carattere;
________12________
ORD('carattere') - Restituisce il codice ASCII del carattere specificato tra parentesi. Es.: k:=chr('n'). La variabile k restituirà il codice ASCII del carattere "n", cioè 110.
Esempio1:
Program carattere;
a:integer;
b:='v';
Esempio2:
Program carattere; ________13________
PI - Restituisce il valore del pi-greco. Es.: s:=PI. La variabile s sarà uguale a 3.1415926536.
Esempio1:
Program pigreco; begin writeln(PI:0:10); readln; end.
Esempio2:
Program circonferenza;
C:=2*(PI)*r;
readln;
________14________
UPCASE('carattere') - Restituisce in maiuscolo il carattere specificato tra parentesi. Es.: q:=UPCASE('t'). La variabile q sarà uguale a "T".
Esempio1: Program maiuscolo; var a,b:char; begin a:='m'; b:=UPCASE(a); writeln(b);
readln;
Esempio2: Program maiuscolo; var b:char; begin b:=UPCASE('a'); writeln(b);
readln;
________15________
SIN(variabile) - Calcola il seno della variabile specificata tra parentesi. Es.: r:=SIN(34). La variabile r sarà uguale a 0.53.
Esempio1: Program seno; var b:real;
a:integer;
a:=88;
readln;
Esempio2: Program seno; var b:real; begin b:=SIN(102); writeln(b:0:2);
readln;
________16________
COS(variabile) - Calcola il coseno della variabile specificata tra parentesi. Es.: s:=COS(31). La variabile s sarà uguale a 0.91.
Esempio1: Program coseno; var b:real;
a:integer;
a:=55;
readln;
Esempio2: Program coseno; var b:real; begin b:=COS(102); writeln(b:0:2);
readln;
________17________
ARCTAN(variabile) - Calcola l'arcotangente della variabile specificata tra parentesi. Es.: t:=ARCTAN(13). La variabile t sarà uguale a 1.49.
Esempio1: Program arcotangente; var b:real;
a:integer;
a:=43;
readln;
Esempio2: Program arcotangente; var b:real; begin b:=ARCTAN(18); writeln(b:0:2);
readln;
Torna su é Quando nel codice sorgente sono presenti degli errori, al momento dell'esecuzione, vengono visualizzati dei messaggi in inglese che molto sinteticamente cercano di far comprendere all'utente l'errore commesso; il compilatore inoltre ferma il cursore sulla riga contente l'errore. Di seguito sono elencati e spiegati (con i relativi codici) i principali messaggi di errore che si visualizzano in un compilatore Pascal.
2) IDENTIFIER EXPECTED - (dall'ingl.: identificatore aspettato): indica che in quel punto del codice deve essere presente una variabile.
3) UNKNOWN IDENTIFIER - (dall.ingl.: identificatore sconosciuto): indica che un elemento del programma è sconosciuto al compilatore (esempio: una variabile non dichiarata, un scritta che non fa parte del codice sorgente ecc).
4) DUPLICATE IDENTIFIER - (dall'ingl.: identificatore duplicato): indica che il nome del programma coincide con il nome di una variabile o che due variabili hanno lo stesso nome.
5) SYNTAX ERROR - (dall'ingl.: errore di sintassi): indica che un'istruzione è stata scritta con una sintassi errata.
8) STRING COSTANT EXCEEDS LINE - (dall'ingl.: la costante stringa eccede nella linea): indica che il testo di un messaggio fra parentesi non è stato inserito fra apici, oppure che si è dimenticata la chiusura degli apici stessi. Esempio: WRITELN(MESSAGGIO1); <-- senza apici ERRORE WRITELN('MESSAGGIO2); <-- manca l'apice di chiusura ERRORE
10) UNEXPECTED END OF FILE - (dall'ingl.: inaspettata fine dell'archivio): indica che il numero dei BEGIN non è uguale al numero degli END, cioè non è indicata la fine del programma con l'istruzione END..
11) LINE TOO LONG - (dall'ingl.: linea troppo lunga): indica che una riga del codice sorgente supera 127 caratteri, cioè il massimo dei caratteri utilizzabili per una riga.
15) FILE NOT FOUND - (dall'ingl.: archivio/file non trovato): indica che un file, a cui si fa riferimento nel programma, non è stato trovato nella directory corrente o in nessuna delle directory impostate per la ricerca. Questo errore si presenta generalmente quando le UNIT (o librerie) non sono localizzate nella loro cartella (chiamata UNITS), oppure quando si lavora con file esterni. Si consiglia, quindi, di rivedere l'esatto path (percorso, localizzazione) del file a cui si fa riferimento.
26) TYPE MISMATCH - (dall'ingl.: discordanza di carattere): indica che una variabile è diversa da come è stata dichiarata, oppure che c'è un'incompatibilità tra i tipi di operandi in un'espressione. Esempio1: ... var a:integer; begin a:=10.23; <-- ERRORE: il numero 10.23 non è un numero intero (INTEGER). ...
Esempio2: ... var a:integer; begin a:=3/7; <-- ERRORE: la divisione genera sempre un numero reale ...
36) BEGIN EXPECTED - (dall'ingl.: "begin" aspettato): indica che in quel punto del codice è necessario un BEGIN.
37) END EXPECTED - (dall'ingl.: "end" aspettato): indica che in quel punto del codice è necessario un END.
42) ERROR IN EXPRESSION - (dall ingl.: errore nell'espressione): indica che il simbolo scritto nel codice non può partecipare all'espressione nel modo in cui è stato scritto, oppure che è stato dimenticato un operatore tra 2 operandi. Questo errore si presenta specialmente quando si indicano errate espressioni nella struttura CASE...OF. Esempio: ... var a:integer; begin write('Scrivi un numero '); readln(a); CASE a OF >3:... <-- ERRORE: l'intervallo può essere scritto in questo modo 1..3 ... ...
50) DO EXPECTED - (dall'ingl.: "DO" aspettato): indica che in quel punto del codice dovrebbe esserci la parola riservata DO.
57) THEN EXPECTED - (dall'ingl.: "THEN" aspettato): indica che in quel punto del codice dovrebbe esserci la parola riservata THEN.
58) TO OR DOWNTO EXPECTED - (dall'ingl.: "TO" o "DOWNTO" aspettato): indica che in quel punto del codice dovrebbe esserci la parola riservata TO o DOWNTO.
62) DIVISION BY ZERO - (dall'ingl.: divisione per zero): indica che è stata effettuata una divisione per zero (tramite / o DIV o MOD).
85) ";" EXPECTED - (dall'ingl.: ";" aspettato): indica che manca il punto e virgola alla fine di una determinata riga.
86) ":" EXPECTED - (dall'ingl.: ":" aspettati): indica che mancano i due punti in una determinata istruzione.
88) "(" EXPECTED - (dall'ingl.: "(" aspettata): indica che non è stata aperta una parentesi tonda successivamente chiusa.
89) ")" EXPECTED - (dall'ingl.: ")" aspettata): indica che non è stata chiusa una parentesi tonda precedentemente aperta.
91) ":=" EXPECTED - (dall'ingl.: ":=" aspettati): indica che mancano i due punti e l'uguale in una determinata istruzione.
113) ERROR IN STATEMENT - (dall'ingl.: errore nella dichiarazione): indica che il simbolo scritto non può dare inizio ad una dichiarazione.
Torna su é |
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||