FreeBASIC – lavorare con i files [4]

Nel precedente articolo abbiamo visto la modalità di accesso binary per lavorare con i files binari.

Oggi vedremo come creare un database: ovvero un file binario contenente dati organizzati in records.

Possiamo immaginare un record come una singola riga di una tabella contenente una o più di queste righe. Un record è composto a sua volta da uno o più campi che contengono ciascuno uno specifico tipo di dato (stringa, intero, ecc.). I records devono avere una lunghezza in bytes predefinita.

Per accedere ai campi dei singoli records si utilizza la modalità di accesso random.

Prima però di aprire un file binario in modalità random, è necessario definire il tipo di dato che rappresenterà il nostro record . Abbiamo già visto come farlo nell’articolo che trattava appunto il tipo di dato definito dall’utente.

Vediamo un esempio:

'definizione del tipo di dato (record)
type persona
nome as string * 10
cognome as string * 20
anno_di_nascita as integer
patente as boolean
end type

'dimensionamento e creazione della variabile associata al record
dim p1 as persona
dim p2 as persona
dim px as persona

'valorizzazione dei dati
p1.nome = "Mario"
p1.cognome = "Rossi"
p1.anno_di_nascita = 1977
p1.patente = false
p2.nome = "Maria"
p2.cognome = "Bianchi"
p2.anno_di_nascita = 1985
p2.patente = true

'crea il file
open "mio_db.dat" for random as #1 len=sizeof(persona)
put #1, 1, p1
put #1, 2, p2
close #1

'apri il file e leggi un dato
open "mio_db.dat" for random as #1 len=sizeof(persona)
get #1, 2, px
close #1

'stampa i dati del record 2
print "Nome: "; px.nome
print "Cognome: "; px.cognome
print "Anno di nascita: "; px.anno_di_nascita
print "Patente: "; px.patente

Come avrete notato è stato necessario, sia in fase di creazione che di lettura del file binario, specificare la lunghezza in byte del record. Per farlo si è utilizzata la funzione sizeof().

Bene. Con i files per adesso possiamo fermarci qui.

Nei prossimi articoli inizieremo a creare le nostre prime finestre grafiche. 🙂

FreeBASIC – lavorare con i files [3]

Dopo aver trattato nei precedenti due articoli i files di testo vedendo sia la modalità di scrittura/lettura che la modalità append, in questo nuovo articolo discuteremo di un tipo di file molto particolare: il file binario.

Un file binario è un file che contiene esclusivamente codice binario che può rappresentare qualsiasi tipo di dato.

In FreeBASIC per lavorare con i files binari si utilizza la modalità di apertura binary.

Con questa modalità di apertura si informa il compilatore FreeBASIC che si intende scrivere o leggere dei dati binari.

Puntatore di file

Nel momento in cui si crea un nuovo file binario e si scrive il primo dato, il puntatore del file viene valorizzato a 1.

Scrivere un dato binario

Per scrivere su un file un dato binario, proveniente da un buffer di dati, si utilizza l’istruzione put #.

Leggere un dato binario

Per leggere da un file un dato binario si utilizza l’istruzione get # che riversa i dati su un buffer di dati.

Con un po’ di fantasia, possiamo assimilare il buffer di un computer alla memoria a breve termine di noi umani. 😉

Esempio

dim pi_greco as single
pi_greco = 3.1415

print "La variabile pi_greco e' stata inizializzata al valore: "; pi_greco
 
'Crea il file dati e salva in binario il valore della variabile.
open "prova.dat" for binary as #1
  put #1, , pi_greco
close #1

pi_greco = 0
print "La variabile pi_greco dopo essere stata azzerata vale: "; pi_greco

open "prova.dat" for binary as #1
  get #1, , pi_greco
close #1

print "La variabile pi_greco letta dal file ora vale: "; pi_greco

Abbastanza semplice, no? 🙂

Nel prossimo articolo vedremo invece la modalità di apertura random.

FreeBASIC – lavorare con i files [1]

Dopo un po’ di tempo che si è iniziato a programmare, è inevitabile che sorga l’esigenza di lavorare con delle informazioni salvate su files.

È bene quindi sapere come farlo anche con FreeBASIC.

Istruzione open

L’istruzione che si utilizza in FreeBASIC per lavorare con i files è l’istruzione open.

Di per sé l’istruzione open non specifica cosa in realtà vogliamo fare: se, per esempio, leggere un file esistente, oppure scriverci sopra, o magari crearne uno nuovo.

Per dire al nostro computer cosa vogliamo fare occorre specificare una delle seguenti cinque modalità di apertura:

  1. Per scrivere del testo a partire da un file vuoto (parola-chiave output)
  2. Per leggere il contenuto testuale (parola-chiave input)
  3. Per aggiungere del testo ad un file esistente (parola-chiave append)
  4. Modalità binaria (parola-chiave binary)
  5. Modalità casuale (parola-chiave random)

In questo articolo vedremo le prime due.

Creare un file di testo (output)

Proviamo a creare il nostro primo file di testo:

dim nome_file as string
dim numero_file as long

nome_file = "prova.txt"
numero_file = freefile 'restituisce un numero di file libero

open nome_file for output encoding "utf8" lock write as #numero_file
print #numero_file, "FreeBASIC è figo!"
close #numero_file

Vediamo di spiegare nel dettaglio cosa abbiamo fatto.

Numero del file

In FreeBASIC è necessario identificare il file su cui stiamo lavorando con un numero.

Nonostante siamo liberi di specificare direttamente noi un valore che sia compreso tra 1 e 255, è preferibile utilizzare la funzione freefile che evita il rischio di utilizzare un valore già in uso.

Nome del file

Se nella stringa del nome del file non viene specificato alcun percorso, il file verrà aperto nella cartella corrente (vedi anche la funzione curdir).

Codifica dei caratteri

Per quanto riguarda la scelta della codifica dei caratteri, in FreeBASIC possiamo sceglierne una tra le seguenti quattro attraverso l’istruzione encoding:

  1. ASCII: digitando “ascii” (codifica di default se non specificata)
  2. UTF-8: digitando “utf8” (codifica consigliata dal W3C)
  3. UTF-16: digitando “utf16”
  4. UTF-32: digitando “utf32”

Accessibilità al file

Con l’istruzione lock si può specificare se l’accesso al file è esclusivo o se ne è permesso l’accesso in lettura o scrittura anche ad altri programmi presenti sul nostro computer:

  • read: impedita la lettura da parte di altri programmi
  • write: impedita la sola scrittura
  • read write: accesso totalmente negato ad altri programmi (valore di default)

Come leggere un file di testo

Proviamo ora a leggere il contenuto del file appena creato utilizzando la modalità input e aggiungendo al nostro programma le seguenti linee di codice:

dim riga_di_testo as string

numero_file = freefile

open nome_file for input as #numero_file
line input #numero_file, riga_di_testo
close #numero_file

print riga_di_testo

Compilando e mandando in esecuzione il programma ci accorgiamo subito che la lettura del carattere accentato “è” non è andata a buon fine. Questo perché non avendo specificato la codifica dei caratteri, di default FreeBASIC ha interpretato il testo come codificato in ASCII. Basterà quindi modificare il codice aggiungendo la codifica in UTF-8 e la lettura del testo sarà corretta.

Modalità di lettura

Per leggere il contenuto di un file di testo abbiamo due diverse istruzioni:

  • line input #: che permette la lettura di una intera riga di testo sino al carattere di fine riga che viene scartato;
  • input #: che permette la lettura di valori separati da virgola (ne parleremo nel prossimo articolo).

Intercettare la fine di un file

Una volta scelta la modalità di lettura, dovremo inserirla in un ciclo in modo tale da leggere tutto il contenuto del file.

Qui si pone un problema: quando uscire dal ciclo di lettura?

Niente panico! FreeBASIC ci mette a disposizione la funzione eof che restituisce il valore -1 (true) se si è raggiunta la fine del file, altrimenti viene restituito il valore 0 (false).

Bene! Per oggi ci fermiamo qui.

Nel prossimo articolo continueremo comunque ad approfondire l’argomento e vedremo come lavora la modalità di apertura append. 🙂