PASCAL (parte I)

eZine lover (@eZine)

Published in 

bakunin

 · 2 years ago

BAKUNIN
bakunin@meganmail.com

Dato che XXXX non sapeva programmare in Pascal ho deciso di spiegarvi questo linguaggio. Questo è stato il mio 3 linguaggio di programmazione imparato. E' molto semplice ed infatti l'ho imparato in non più di un mese.

Passiamo quindi subito con il lavoro tralasciando la parte sentimentale e di ricordi.

Come quindi ogni altra guida, eccovi l'indice:

INDICE

1. Materiale occorrente
2. Strutture base
3. Dichiarazioni
• a) USES
• b) CONST
• c) VAR
4. Istruzioni base
• a) READLN
• b) WRITELN
5. Operazioni aritmetiche
6. IF
7. WHILE
8. FOR
9. REPEAT UNTIL
10. CASE
11. Operatori booleani
12. Array e matrici
13. Comandi vari
14. Programmone
15. Pausetta
16. File vari
17. Procedure
18. File

1. Materiale occorrente

Per programmare in PASCAL si necessita di un programma. Questo si chiama (provate ad indovinare...) TURBO PASCAL. Ce ne sono varie versioni, io usavo la 5 poi sono passato alla 7.

TURBO PASCAL 7 è (credo) l'ultima versione uscita. E' un po' vecchiotta ma semplicemente per il fatto che non si programma più in pascal. Questo però non è del tutto vero, infatti dovete sapere che funzionando sotto DOS, si possono creare dei bei virus, o addirittura vere e proprie applicazioni.

Se non avete Turbo Pascal 7 a portata di mano potete scaricarlo dalla sezione Programmi del Tank Commandos Web Site (http://go.to/tankcommandos)
Col passare del tempo sono nate delle librerie nuove (vi spiegherò poi cosa sono) che hanno permesso di programmare applicazioni per windows. Dopo altro tempo sono uscite quelle per LINUX.

Ora come ora il PASCAL è conosciuto comunemente solo sotto DOS. Si può scaricare da internet, ma è complicato da trovare. Ma dovete sapere che (sempre per il fatto che su LINUX tutto è gratis) esiste un sito (www.freepascal.com ma non ne sono sicuro!) ove è possibile scaricare la versione per linux. Questa versione crea applicazioni sia per DOS, sia per windozz, e sia per Linux.

Comunque ora incominciamo!

2. Strutture base

Ogni programma ha dei punti fissi. Questi sono le intestazioni, le dichiarazioni e le istruzioni. Le intestazioni servono solo da titolo del programma per chi usa i file sorgenti (cioè quei file che non sono ancora resi programmi eseguibili).

Come comandi ce ne solo uno:

PROGRAM nome_programma;

Si può scrivere sia minuscolo che maiuscolo, ma non si possono dare spazi al nome.
Il comando è il program, è facoltativo e necessita di un nome subito dopo. Questo nome non deve avere spazi ma si possono utilizzare tranquillamente le _ .

Le Dichiarazioni sono quelle zone dove si devono inserire le librerie da utilizzare, le variabili e le strutture. Tutto sarà spiegato.

Successivamente ci saranno le istruzioni. Queste conterranno i reali comandi.

Lo schema quindi sarà:

PROGRAM ciao_bello; INTESTAZIONE 

...DICHIARAZIONI... 

BEGIN 

... 
e qui le ISTRUZIONI 
... 

END.

Cosa abbiamo già scoperto senza saperlo? Ora sappiamo che le istruzioni devono incominciare con un BEGIN e devono finire con un END. Mica male!

L'intestazione non serve a nulla e spesso non si mette. Io penso che l'ho utilizzata 2 volte in tutta la mia vita.

3. Dichiarazioni

Partiamo con le dichiarazioni. Queste si dividono in 3 parti bene precise: USES, VAR e CONST.

USES

Nella sezione USES si regolano le librerie che ci interessano. Queste sono tante, addirittura se avrò voglia un giorno vi spiegherò come crearvene di vostre. Per ora dovete sapere che le più usate sono la CRT (che regola i collegamenti tastiera e monitor), la DOS (che regola le principali operazioni di apertura, chiusura dei file e le loro modificazioni), la PRINTER (regola la stampa), la GRAPH (l'aspetto grafico). Ce ne sono molte altre, ma per ora preoccupiamoci di queste.

L'uso di questo comando è:

USES CRT,DOS,... tutte quelle che vi servono;

Vi chiederete: Ma perché non le posso mettere tutte e poi uso quelle che mi capitato? Questo non si fa per il fatto che certe in particolare richiedono trafile di codici per funzionare e non è intelligente creare un file lunghissimo soltanto poi per bellezza. Poi certe librerie escludono altre entrando in conflitto oppure ne modificano il comportamento.

CONST

Le costanti si possono usare semplicemente così:

CONST nome:=numero

Quindi un esempio è:

CONST pigreco:=3.14;

Questo è un semplice esempio che però ci vela molte cose. Ad esempio che con l'opzione := io rendo uguale, associo un numero ad una costante.
Scopriamo anche che tutte le righe di comando finiscono con ; . Non proprio tutte, le uniche che esulano da questo ; sono il BEGIN che non vuole nulla e l'ultimo END che necessita di un .

VAR

Le variabili devono essere dichiarate. Cosa vuol dire? Vuol dire che all'inizio del programma io devo sapere subito quali variabili necessitano. O meglio, il programma quando si avvia deve sapere quali variabili possiede durante la sua esecuzione.

Un esempio di questo comando è:

VAR A,B:tipo variabile.

Ove A e B sono le variabili che io voglio usare. I tipi di variabili che io posso utilizzare sono milioni. Ora vi faccio un elenco delle più utilizzate:

---------------------------------------------------------------------- 
|        | CONTIENE I NUMERI COMPRESI TRA      |                     | 
| BYTE   | 1 A 255                             |       1 BYTE        | 
---------------------------------------------------------------------- 
|        | PERMETTE DI RAPPRESENTARE TUTTI I   |                     | 
| REAL   | VALORI DECIMALI COMPRESI TRA:       |       6 BYTE        | 
|        | ±2.9 * 10 ^-38 A ±1.7 * 10^38       |                     | 
---------------------------------------------------------------------- 
|        | CONSENTE DI RAPPRESENTARE VALORI    |                     | 
|INTEGER | INTERI RELATIVI COMPRESI TRA:       |       2 BYTE        | 
|        |      -32768 E +32767                |                     | 
---------------------------------------------------------------------- 
|        | CONSENTE DI RAPPRESENTARE GLI INTERI|                     | 
|LONGINT | COMPRESI TRA:                       |       4 BYTE        | 
|        |     -2147473648 E +2147483647       |                     | 
---------------------------------------------------------------------- 
|        | PERMETTE DI RAPPRESENTARE TUTTI     |                     | 
| CHAR   | I CARATTERI APPARTENENTI            |       1 BYTE        | 
|        | ALL'ALFABETO ASCII                  |                     | 
---------------------------------------------------------------------- 
|        | PERMETTE DI RAPPRESENTARE UNA       |                     | 
| STRING | QUALSIASI SEQUENZA DI CARATTERI LA  |   FINO A 255 BYTE   | 
|        | CUI LUNGHEZZA VARIA DA 1 A 255      |                     | 
---------------------------------------------------------------------- 
|        | PERMETTE DI RAPPRESENTARE I DUE     |                     | 
|BOOLEAN |   VALORI LOGICI TRUE E FALSE        |       1 BYTE        | 
-----------------------------------------------------------------------

Un esempio quindi di tutto fin ora potrebbe essere:

-----INIZIO----------- 

PROGRAM ciao_bello; 

USES CRT,DOS; 

CONST A:=123,B:=456; 
VAR C,D:STRING; 
    E,F:INTEGER; 

BEGIN 
END. 

---------FINE----------

Ogni singolo tipo di variabile può contenere già dentro se un massimo valore.
Questa opzione si fa così:

VAR CIAO:STRING[56];

Questo vuol dire che la variabile CIAO che può contenere parole o frasi (poiché e string) ha come massima lunghezza 56 spazi.

4. Istruzioni

Ora preoccupiamoci della zona destinata ai codici.
Incominciamo subito con i più semplici:

READLN(Variabile);

Aspetta che l'utente inserisca un valore. Questo sarà inserito nella variabile contenuta tra le due parentesi.
ES:

USES CRT,DOS; 

VAR A:CHAR; 

BEGIN 
READLN(A); 
END.

Cosa questo programma aspetta che l'utente inserisca dei caratteri. Questi verranno accolti come caratteri ASCII e quindi se inserisco numeri poi non posso sommarli. Se dichiariamo la variabile A come CHAR. Non posso fare altro che scrivere.

Se avessi inserito invece che CHAR, l'opzione INTEGER se carico in A un numero posso poi fare operazioni aritmetiche.

Semplice!

Un altro comando è il WRITELN. Questo mostra sullo schermo quello che inserisco tra le parentesi. Quello che sta tra parentesi può essere o il contenuto di una variabile, o una frase in particolare o entrambi.
Esempio:

-------INIZIO--------- 

USES CRT,DOS; 

VAR A:INTEGER; 

BEGIN 
WRITELN('DAMMI UN NUMERO: '); 
READLN(A); 
WRITELN('IL NUMERO CHE MI HAI INSERITO: ',A ); 
END. 

--------FINE----------

Cosa ho fatto? Ho regolato la variabile. Ho chiesto all'utente di darmela. E poi glielo ridata.
Vi ho anche detto che, per ridare la variabile basta dire:

WRITELN(A);

per scrivere:

WRITELN('CIAO');

per fare entrambi si usa la virgola tra l'uno e l'altro:

WRITELN(A,'ciao bello!!',B);

EX CLARO?

Un altra opzione di WRITELN è la possibilità di stampare. Se io metto tra le librerie PRINTER posso stampare così:

WRITELN(LST'La variabile che hai inserito è',A);

LST permette la stampa e non la visualizzazione sullo schermo.

5. Operazioni aritmetiche.

Per fare calcoli si fa semplicemente così:

A:=B+C;

Sommo Be C e metto il risultato in A.
Posso però anche fare così:

A:=B-C; 
A:=B*C; 
A:=B/C;

Queste solo le alte 3 operazioni.

Una cosa che spesso non si sà è che posso fare anche così:

A:=A+3;

Cosa ho fatto? Ho sommato alla variabile A (che devo prima sapere attraverso il comando READLN) il numero 3 e poi il risultato lo ri-inserito nella variabile A.
Se quindi faccio:

A:=3; 
A:=A+4;

A sarà 7.
Questo vale ovviamente per tutte le operazioni aritmetiche.

Per capire se avete capito ora faccio questo semplice programmino:

-------INIZIO------------- 
PROGRAM SOMMA_DI_2_NUMERI; 

VAR A,B,C:INTEGER; 

BEGIN 

WRITE('DIMMI 2 NUMERI SEPARATI DA UNO SPAZIO:'); 
READ(A,B); 
C:=A+B; 
WRITELN('IL RISULTATO E'': ',C); 

END. 
--------FINE-------------

O mio dio, cosa è successo? Nulla di ché! Ho usato al posto del comando WRITELN il comando WRITE e al posto del READLN il comando READ. Cosa cambia? Cambia che non mi manda a capo ogni fine istruzione. Se avessi usato WRITELN e READLN avrei avuto:

DAMMI 2 NUMERI SEPARATI DA UNO SPAZIO:
e qui la richiesta dei numeri

Il programma invece fa così:

DAMMI 2 NUMERI SEPARATI DA UNO SPAZIO: e qui la richiesta dei numeri

Che ritengo migliore!

Poi cos'è quel READ(A,B); ? Nulla! Vuol dire che chiedo all'utente di inserire 2 variabili al posto che una e lo faccio con un solo comando.

Poi c'è quel E''. Cos'è? Se io faccio e' l'apostrofo viene considerato come chiusura del WRITELN. Se faccio così, no ed ottengo così:

IL RISULTATO E':

6. IF

If è molto usato per la gestione delle possibilità. L'uso corretto è:

IF A<0 THEN ... se a è minore di 0 allora...
o
IF A=0 ... se A è uguale a 0 allora...
IF A>0 ... se A è maggiore di 0 allora...
IF A<=0 ... se A è minore uguale di 0 allora...
IF A>=0 ... se A è maggiore uguale di 0 allora...
IF A<>0 ... se A è diverso da 0 allora...

Ovviamente A deve essere una variabile inizializzata e deve contenere dei valori.
Notate tra le altre cose che è messo A=0 e non A:=0. perché? perché nel secondo caso io obbligo A ad assumere il valore di 0 e non lo confronto con esso come invece mi è utile fare.

In più l'IF si può utilizzare anche così:

IF A<0 THEN BEGIN 
 ... 
 OPERAZIONI 
 ... 
END;

Si possono quindi aprire cicli di di operazioni da vare nel caso tale operazione si verifica.
Esiste collegato ad IF il comando ELSE che, ovviamente vuol dire "altrimenti".

IF A<0 THEN...(quando A quindi vale -1, -2, -56, -3445, tutto quello che volete voi!)
ELSE... (quando A vale 2,65,3556,...)

Esempio pratico:

-------INIZIO----------- 
PROGRAM MAGGIORE_O_NO; 
VAR A,B:INTEGER; 

BEGIN 
 WRITELN('DAMMI IL VALORE DI A E DI B SEPARATI DA UNO SPAZIO.'); 
 READLN(A,B); 
 IF A>B THEN WRITELN('IL NUMERO ',A,' E'' MAGGIORE DI ',B) 
 ELSE WRITELN('IL NUMERO ',A,' E'' MINORE DI ',B); 
END. 

--------FINE------------

Cos'è questo? Ho chiesto 2 numeri, li ho confrontati e ho valutato qual è quello maggiore rispetto all'altro. Fondamentale è notare che non ho messo il ; dopo la prima riga dell'IF. Questo perché se poi metto ELSE questo non funziona.

Se quindi facessi:

IF A>0 THEN BEGIN 
..tante belle cose... 
END 
ELSE 
...

Notate che dopo END non c'è il ;. Questo è per il fatto di prima.

7. WHILE

Si usa così:

WHILE A<0 DO BEGIN 
...varie operazioni... 
A:=A+1; 
END;

Ripete le operazioni contenute tra il DO e la fine (nel nostro caso l'END; perché ho aperto un BEGIN), fino a quando quella operazione (A<0) è vera. Ovviamente per non ripetere all'infinito il ciclo, bisogna far aumentare A e, soprattutto prima di iniziare il ciclo dargli un valore!

Sarebbe sbagliato (o meglio, andrebbe all'infinito) se facessi:

WHILE A<0 DO BEGIN 
A:=-2 
END;

perché imposto A come -2 sempre e quindi pianto il sistema!

8. FOR

Questo ciclo ripete per tot numero di volte delle sequenze di comandi. Questo si usa così:

FOR A:=0 TO 9 DO ...

Imposto prima A (che deve essere inizializzata!) come 0 e poi dico di ripetere questo ciclo finché A non raggiunge il valore di 9. Ci penserà poi il programma a aumentare A.

Quindi è giusto dire:

FOR A:=0 TO 10 DO WRITELN('A vale ',A);

Come riposta avrò:

0 
1 
2 
3 
4 
5 
6 
7 
8 
9

e poi il programma finisce.

9. REPEAT UNTIL

Questo contatore si usa così:

REPEAT 

...operazioni varie... 

A:=A+1; 

UNTIL A<10;

Se ovviamente mi dimentico di aumentare A ottengo un ciclo perenne.

10. CASE

Il case studia il tipo di valore che una variabile contiene.
Si usa così:

CASE (A) OF 
1: BEGIN 
.... 
   END; 
2: BEGIN 
   ... 
   END; 
END;

Cosa vuol dire? Case studia il valore di A. Se questo è uguale a 1 farà le operazioni contenute dopo 1. Se è uguale a 2, ovviamente farà le altre.

11. Operatori booleani

Ovviamente per ogni singolo ciclo si possono usare comandi particolari che permettono di confrontare più variabili. Questi sono gli operatori booleani:

-------------------------------------------------------------------------- 
| AND  	|   e	| IF (A<0) AND (b>0) THEN 	| Devono essere vere     | 
|	|	|				| entrambe le variabili  | 
-------------------------------------------------------------------------- 
| OR	|   o	| IF (A<0) OR (b>0) THEN	| Basta che una delle due| 
|	|	|				| via vera		 | 
--------------------------------------------------------------------------

Direi basta. Ma non ne sono sicuro...

Vedete comunque che in questi casi compaiono le parentesi.

12. ARRAY

Gli array sono dei pacchetti di variabili contenenti più dati dello stesso tipo.
Si usa così:

VAR A:ARRAY[1..10] OF STRING;

La variabile A potrà contenere 10 risposte tutte quante string. Per utilizzarle basta fare così:

WRITELN('Dimmi la prima'); 
READLN(A[0]); 
WRITELN('Dimmi la seconda'); 
READLN(A[1]);

e così di seguito.

Osservate che se io regolo l'ARRAY da 1 a 10 la prima variabile non sarà A[1] ma è A[0].

Questo è l'uso non c'è altro da dirvi.

Collegato all'ARRAY ci sono le matrici. Queste sono delle variabili a tabella.
Se un ARRAY inserisce dati in un'unica variabile in fila:

----------------- 
|0|1|2|3|4|5|6|7|... 
-----------------

la matrice lo farà a tabella:

----------------- 
|0|1|2|3|4|5|6|7|... 
----------------- 
|0|1|2|3|4|5|6|7|... 
----------------- 
|0|1|2|3|4|5|6|7|... 
----------------- 
|0|1|2|3|4|5|6|7|... 
----------------- 
....................

Come si creano?

Come le altre:

VAR A:ARRAY[1..10,1..10] OF INTEGER;

Chiaro?
Ovviamente il numero 10 non è fisso, ma non vi credo così cogl_oni da pensarlo!

Ovviamente ogni singolo numero può essere "variabilizzato".
ES:

--------INIZIO---------------- 

VAR A,B:INTEGER; 
    C:ARRAY[1..A] OF STRING; 
BEGIN 
 WRITE('QUANTE PAROLE VUOI DARMI?'); 
 READ(A); 
 A:=A+1; 
 FOR B:=1 TO A DO 
  BEGIN 
  WRITE('BENE! DIMMI LA ',B,'∞ PAROLA:'); 
  READ(C[B]); 
END. 

---------FINE---------------

Questo programmino regola 2 variabili integer e un array che va fino a 1 delle due variabili precedenti. Chiede A e quindi regola anche il numero di ARRAY di C. Poi effettua un ciclo chiedendo tutte le parole da 0 a A. perché ho fatto A:=A+1? perché se non lo avessi fatto mi sarebbe apparsa la scritta : DIMMI LA 0∞ PAROLA: mentre aumentano il valore di A di uno, e facendo partire B da 1 al posto che da 0 il risultato non cambia.

Non è complicata l'esecuzione: è soltanto logica.

EX CLARO?

13. Comandi vari

DELAY Questo comando manda in pausa il programma per tot millesimi di secondi.

DELAY(1000);

ferma per un secondo.

CLRSCR:

Pulisce lo schermo

GOTO(X,Y)

posiziona il puntatore in un preciso punto sullo schermo

CHR(a) vuol dire un carattere ascii in particolare
Si usa così:

b:=CHR(24);

Ove b è una variabile inizializzata come char.

TEXTBAKGROUND(colore) Imposta lo sfondo di un colore preciso

TEXTCOLOR(colore) Imposta la scritta di un colore

Le modalità di colore sono:

------------------------- 
| 0 	| NERO		| 
| 1     | BLU           | 
| 2     | VERDE         | 
| 3     | VIOLETTO      | 
| 4     | ROSSO         | 
| 5     | MAGENTA       | 
| 6     | MARRONE       | 
| 7     | GRIGIO        | 
------------------------- 
| Quelli sotto valgono  | 
| soltanto per il       | 
| comando TEXTCOLOR     | 
| e non per l'altro     | 
------------------------- 
| 8     | GRIGIO SCURO  | 
| 9     | BLU CHIARO    | 
| 10    | VERDE CHIARO  | 
| 11    | VIOLA CHIARO  | 
| 12    | ROSSO CHIARO  | 
| 13    | MAGENTA CHIARO| 
| 14    | GIALLO        | 
| 15    | BIANCO        | 
-------------------------

I colori successivi sono gli effetti ad intermittenza.

KEYPRESSED sente un pulsante della tastiera a caso senza riconoscerlo. Questo comando è molto utile in questo caso:

REPEAT UNTIL KEYPRESSED

che aspetta un tasto premuto

TYPE serve per ridurre parte di programma. Non è proprio così, ha innumerevoli altre funzioni ma per ora vedetelo così:

TYPE CASA=FILE OF STRING[23] 
VAR CIAO:CASA;

Vuol dire che mi basta scrivere casa per intendere FILE OF STRING[23].

HALT finisce subito il programma ed esce. Serve per bloccare il tutto.

14. Programmone

PROGRAMMONE che serve a calcolare le medie fra i vari voti.

---------INIZIO--------------- 
(*Così faccio i commenti!*) 
uses crt; 
var voti,a,c,cio,media:integer; 
begin 
 clrscr; 
 textcolor(9); 
 write('PROGRAMMINO CHE CALCOLA LE MEDIE FRA VOTI!'); 
 writeln;writeln;        (*Metto 2 linee vuote*) 
 write('Dimmi i numeri di voti che vuoi inserire: '); 
 read(voti); 
 writeln;writeln; 
 media:=0; 
 for a:=0 to voti do 
   begin 
   c:=a+1; 
   write('Dimmi il ',c,'∞ voto: '); 
   read(cio); 
   media:=cio+media; 
   end; 
 media:=media/voti; 
 writeln('La media dei tuoi voti e'' ',media); 
 writeln;writeln; 
 writeln('premi un tasto per uscire...'); 
 repeat until keypressed; 
end. 
--------FINE------------------

Semplice no? Chiedo quanti voti ha da sommare. Incomincio il ciclo che parte da 0 e arriva al numero dei voti da inserire. Copio il voto nella variabile cio e poi lo aggiungo alla media. Divido tutto per il numero dei voti e ottengo il risultato.

Non l'ho provato ma credo sia giusto.

-------------FINE PRIMA PARTE----------------

15. Pausetta...

------------INIZIO SECONDA PARTE------------

16. File vari

Questa parte è già più che sufficiente per una conoscenza del linguaggio PASCAL. Ma dato che sono buono dovete sapere ancora un paio di cose. I PASCAL dato che è nato come linguaggio da insegnamento, ha un fantastico HELP che, seppur in inglese, permette di capire molte cose che non si sanno. Ad esempio le librerie. Setacciate tutte l'HELP alla ricerca delle librerie e scoprirete un casino di cose interessanti.

Detto ciò li parlerò ora di come usare la grafica. Scrivete tra le librerie anche GRAPH e incominciamo!

USES GRAPH, CRT, DOS, ...

Per prima cosa bisogna inizializzarla dandogli 2 variabili che verranno utilizzate soltanto ed esclusivamente da questa libreria. Devono essere 2 variabili integer.

USES GRAPH,CRT; 
VAR A,B:INTEGER; 
BEGIN 
INITGRAPH(A,B,''); 
END.

Cosa vuol dire? Vuol dire che il computer userà le 2 variabili per mettere tutto a posto sullo schermo, e le 2 virgolette per sapere dove trovare la il file.BGI della grafica.
Cos'è questo file.BGI? E' il file della grafica che deve essere contenuto nella directory del file. Se non lo è, o lo spostate o lo indirizzate lì.

Nel secondo caso basta fare:

INITGRAPH(A,B,'c:\tp7\bgi\');

Ho ipotizzato che il file sia contenuto nella directory BGI sotto la sottodirectory TP7.

EX CLARO?

Io sconsiglio questo metodo per una semplice ragione. Quando io compilo un file.pas e lo rengo.exe, oltre a controllare che non ci siano errori, il programma controlla che ci siano i giusti collegamenti. Questo vuol dire che se poi salvo il file.exe in un dischetto, magari questo non funziona.

Cosa bisogna fare per farlo funzionare. Semplice, basta inserire nel dischetto oltre al file.exe anche le librerie, che sono nel nostro caso il file di grafica .bgi. Non è difficile da trovare. Basta scegliere quello opportuno per le nostre esigenze.

Oltre a questo, altre librerie necessitano di essere inserite. Queste mediamente sono .tpu (o .tpw se per Windozz). Soltanto quando uso librerie strane. Le librerie strane non sono quelle contenute nel programma base di turbo PACAL ma sono quelle che si comprano ;-( o che si scaricano (o rubano, fate un po' voi!).

Oltre a questo file bisogna sapere che bisogna salvare anche i file di grafica come quelli dei caratteri utilizzati.

Non dubitate comunque. Non è complicato basta provare salvando i file.exe in un dischetto per vedere se funzionano. Mediamente se il programma non ha grafica non ci sono problemi.

Oltre a ciò ci sono anche i file che si utilizza per contenere dati o cose simili, ma questo ve lo spiegherò dopo.

17. Procedure

Le procedure sono dei blocchi di istruzioni che io richiamo quando voglio. Mi servono per alleggerire il file sorgente e non riscrivere parti uguali.
ESEMPIO:

------INZIO------------- 

PROCEDURE cio; 
BEGIN 
 WRITELN('Supercalifragilistichespiralitoso!'); 
END; 

BEGIN 
cio; 
END. 
---------FINE------------

Cosa ho fatto? Ho creato una procedura che mi permette di scrivere Supercalifragilistichespiralitoso! solo una volta senza doverlo sempre riscrivere.
La procedura si chiama cio e si mette prima dell'inizio del codice.

PROCEDURE nome_procedura; 
BEGIN 
...tutte le operazioni che voglio........ 
END;

Questo è molto utile per fare passaggi che altrimenti sarebbero un po' ripetitivi.

18. File

Ora vi spiego come creare file, aprirli e scriverci su.
Incominciamo col dire che per aprire un file serve avere una variabile che lo possa contenere

Per far ciò basta usare il metodo seguente:

type ciao=file of integer; 
var file:ciao;

Bisogna fare così e basta! Si usa type e poi si inizializza una variabile che io ho chiamato file (il nome può cambiare!).

Per poi aprire un file bisogna prima assegnarlo alla variabile. Ciò si fa attraverso il comando ASSIGN.

ASSIGN(file,'c:\autoexec.bat');

Ora, con questo comando la variabile file contiene l'autoexec.bat
Ma così non lo abbiamo ancora aperto. Per aprirlo bisogna usare il comando RESET.

Se quindi vogliamo aprire il file autoexec.bat bisogna fare così:

ASSIGN(file,'c:\autoexec.bat'); 
RESET(file);

Semplice!

Se ora volessimo leggerlo? Il comando è il READ (lo stesso per leggere le variabili da tastiera!). Serve però un'altra variabile e un ciclo.
Il ciclo si usa perché altrimenti viene letta solo la prima riga.
Il Pascal legge una linea alla volta e le salva sulla variabile che io gli assegno.
Questa deve essere un char. Così:

type ciao=file of integer; 
var file:ciao; 
    a:char; 
begin 
 assign(file,'c:\autoexec.bat'); 
 reset(file); 
 repeat 
   read(file,a); 
 until eof(file);

Con questo ciclo leggo riga per riga tutto il file. Io ve lo butto lì. Poi nella sezione testi del sito di Screener_it trovate anche un bel virus per pascal...
Vedrete così come utilizzare il pascal a scopi distruttivi.

Spiegazione del comando eof(file). Il comando eof indica la fine del file. Cioè quando viene letto il carattere eof che è convenzionalmente la fine di ogni file. Questo è un carattere Ascii (e in particolare il 20), che non si utilizza in nessun altro modo.

Per scrivere in un file bisogna usare il comando WRITE (sì, proprio quello per scrivere sullo schermo!). Si usa così:

WRITE(file,b);

b deve essere una variabile che contiene ciò che volete inserire. Dovete quindi prima inizializzare una variabile string di nome b e poi riempirla:

VAR b:STRING; 
BEGIN 
b:='LA MAMMA HA FATTO I GNOCCI!!'; 
.... 
e si continua. 
... 
END.

Poi bisogna ricordarsi che ogni volta che si apre un file bisogna poi chiuderlo altrimenti le modifiche fatte verranno perse. Per chiudere si usa il comando CLOSE(nome_file) e quindi nel nostro caso:

CLOSE(file);

Per creare un file nuovo bisogna usare il comando REWRITE. Ecco un esempio:

ASSIGN(file,'prova.cio'); 
REWRITE(file); 
CLOSE(file);

Bisogna sempre prima inizializzare il file attraverso ASSIGN.

Poi si possono sempre modificare gli attributi di un file rendendolo nascosto.
Questo si fa così:

SetFAttr(file,Hidden);

Ove file è il file inizializzato e Hidden vuol dire nascosto.

Penso che ora sia più o meno tutto.
Per qualsiasi chiarimento... chiamatemi!

-------------------FINE LEZIONE---------------------

BAKUNIN
bakunin@meganmail.com