FreeBASIC – conversione del tipo di variabile

Occhio agli errori

Quando lavoriamo su un programma può presentarsi la necessità di fare delle operazioni tra tipi di variabili differenti.

Questo tipo di operazioni possono presentare dei rischi: per esempio assegnando ad una variabile numerica di tipo short (i cui limiti di memorizzazione vanno da -32768 a +32767) il risultato della somma di due variabili di tipo integer che hanno una capacità di memorizzazione molto più ampia, si può ottenere un risultato sbagliato:

dim a as integer
dim b as integer
dim c as short 'limite: da -32768 a +32767

a = 32766
b= 1
c = a + b
print c 'viene stampato a video il valore corretto 32767

a = 32767
b= 1
c = a + b
print c 'viene stampato a video il valore errato -32768

In questo caso il compilatore FreeBASIC non ci avverte neanche del problema. Quindi occorre assolutamente stare attenti.

Modalità di conversione

Esistono due modalità di conversione di tipo:

  • conversione implicita (coercion)
  • conversione esplicita (conversion)

Modalità implicita

In una espressione con più argomenti, o nelle procedure (nel passaggio degli argomenti o nel ritorno dei risultati), il compilatore FreeBASIC provvede ad operare una serie di conversioni automatiche di tipo di dato secondo i seguenti criteri:

  1. tutte le variabili numeriche con capacità più piccola di quella del tipo integer vengono convertite nel tipo integer;
  2. più in generale, le variabili numeriche vengono convertite nello stesso tipo di dato della variabile con più capacità (vedi Tabella dei limiti dei tipi di dato standard);
  3. se in una espressione compaiono variabili di tipo single, queste vengono convertite in double.

Modalità esplicita

Come programmatori possiamo anche forzare la conversione di tipo chiedendo esplicitamente al compilatore FreeBASIC – per esempio con l’istruzione cast – di operare una determinata conversione.

Oltre all’istruzione cast, esistono diversi operatori e procedure di conversione di tipi di dato che sono predefinite in FreeBASIC. Per esempio:

'funzione str
'converte una espressione numerica in una stringa
dim a as integer
dim b as integer
dim tot as string
a = 3
b = 2
tot = str(a + b)
print tot

oppure:

'funzione val
'converte una stringa in un valore numerico a virgola mobile (double)
dim a as string
dim b as integer
a = "1"
b = 4 + val(a)
print b 'stampa a video 5

A rileggerci nel prossimo articolo dove parleremo delle costanti.

FreeBASIC – letterali

Innanzitutto, cosa intendiamo con il termine letterale?

Un letterale è un valore di tipo numerico (0-9) o booleano (true/false), oppure una stringa di caratteri che il programmatore scrive direttamente nel codice e su cui il compilatore FreeBASIC non fa alcun tipo di elaborazione/calcolo.

Utilizzo dei letterali

Un valore letterale può essere assegnato ad una qualsiasi variabile (o costante) coerentemente al suo tipo (vedi tabella dei tipi standard):

dim as integer mio_numero = 7
dim as boolean mio_valore = true
dim as string mio_testo = "ciao"

Oppure può essere utilizzato direttamente in una espressione:

dim as integer somma
somma = 4 + 3

Un utilizzo più avanzato è come parametro in una procedura. Questo argomento lo tratteremo in uno dei prossimi articoli.

Letterali numerici interi

In FreeBASIC possiamo scrivire un letterale numerico intero (integer, byte, ecc.) in quattro differenti forme:

Forma decimale

Si utilizzano le cifre decimali (0-9) e per i numeri negativi si antepone il simbolo (-):

dim as integer a = 8200364
dim as byte b = -121

Forma esadecimale

Si antepone “&h” alle cifre esadecimali (0-F):

dim as integer a = &h2F
dim as byte b = &h3

Forma ottale

Si antepone “&o” alle cifre ottali (0-7):

dim as integer a = &o34
dim as byte b = &o4

Forma binaria

Si antepone “&b” alle cifre binarie (0-1):

dim as integer a = &b01110
dim as byte b = &b101

Letterali numerici in virgola mobile

Un letterale numerico in virgola mobile è specificato tramite le cifre (0-9) e il simbolo del punto (.) come separatore dei decimali. Per i numeri negativi si antepone il simbolo (). Opzionalmente può avere un esponente:

dim as single a = -3.54
dim as double b = 4576.83457287
dim as double c = 43.42e-4 'elevamento con esponente negativo

Letterali stringa

I letterali stringa sono sequenze di caratteri racchiusi tra doppie virgolette:

dim as string s = "pippo"

I letterali stringa possono contenere le cosiddette sequenze di escape anteponendo alle prime doppie virgolette il simbolo (!):

dim as string s = !"prima riga\nseconda riga"

Anteponento invece il simbolo ($) si forza il compilatore a considerare la sequenza come priva di caratteri di escape:

dim as string d = $"c:\temp"

Letterali booleani

Questi letterali rappresentano i due valori di verità vero/falso:

dim as boolean a = true
dim as boolean b = false

Bene. Per adesso ci fermiamo qui.

Nel prossimo articolo parleremo di conversione del tipo di variabile.

FreeBASIC – commenti

Un commento è una parte di testo inserita nel nostro codice che viene ignorata dal compilatore FreeBASIC.

Commentare il proprio codice è necessario, e farlo bene è molto importante.

Perché è necessario commentare il codice?

Nel momento in cui scriviamo una parte magari abbastanza complessa del nostro codice, è molto probabile che il suo funzionamento ci appaia chiaro ed evidente in quanto lo abbiamo concepito e analizzato in maniera approfondita proprio in quei minuti in cui siamo alla tastiera del nostro computer. Che bisogno c’è quindi di inserire un commento?

Il fatto è che, a distanza di tempo, qualora dovessimo rimettere mano a quella parte del codice, quello che ci era così chiaro ed evidente diventa oscuro e intricato. Facciamo fatica a ricordare la logica sottesa a certi passaggi e il perché di certe scelte.

Ecco allora che un commento sintetico è molto di aiuto nel recupero dei ragionamenti che avevamo a suo tempo sviluppato per arrivare alla scrittura di una specifica parte del codice.

Figuriamoci poi se a metterci le mani dovesse essere qualche altro sfortunato programmatore.

Caratteristiche di un buon commento

Come non commentare è sbagliato, così è un errore commentare tutto:

Se un certo passaggio è autoesplicativo, non c’è alcun bisogno di commentarlo.

Commentiamo quindi soltanto quei passaggi che possono presentare una certa complessità o che magari rappresentano dei punti chiave del nostro codice.

Tipi di commento

Il compilatore FreeBASIC riconosce diversi tipi di commento.

Commento su una sola linea

Per scrivere un commento su una sola linea, lo si fa precedere dal simbolo apice ():

'Questo è un commento su una sola linea.
print "ciao" 'Anche questo è un commento su una sola linea.

oppure al posto dell’apice si può utilizzare la parola rem.

Nota: inserendo un doppio apice al posto del singolo apice , si evita che il compilatore FreeBASIC analizzi comunque il commento alla ricerca, per esempio, di qualche meta-comando quale per esempio #include (i meta-comandi possono infatti essere scritti all’interno di un commento). In pratica tutto ciò che segue il doppio apice viene totalmente ignorato dal compilatore.

Commento su più linee

Per scrivere un commento su più linee lo si racchiude tra i simboli /’ … ‘/:

/'Questo è un commento
su più linee'/

Nel mondo della Tecnologia dell’Informazione (Information Technology) la lingua franca è l’inglese, è bene quindi che ci sforziamo di scrivere i commenti, i nomi delle variabili e delle funzioni in questa lingua.

A rileggerci al prossimo articolo. 🙂

FreeBASIC – librerie

In ambito informatico esiste un modo di dire che più o meno recita così:

Dobbiamo sempre sforzarci di evitare di reinventare la ruota.

Tradotto significa che se qualcuno ha già scritto del software per svolgere un determinato compito e l’ha messo a disposizione della comunità degli sviluppatori tramite una libreria, è buona pratica utilizzarlo all’interno del proprio progetto senza mettersi a riscriverlo per proprio conto da zero.

In FreeBASIC sono disponibili molti files di intestazione che ci permettono di utilizzare agevolmente delle funzioni presenti sia in librerie esterne incluse in FreeBASIC, sia in librerie scritte in FreeBASIC dagli stessi membri della Comunità FreeBASIC.

Le librerie possono essere di due tipi: statiche o dinamiche (DLL).

Nel precedente articolo abbiamo visto come includere i files di intestazione in un file sorgente (o modulo).

Nota: alcune librerie utilizzabili non sono distribuite insieme al compilatore FreeBASIC. Occorre quindi scaricarle e leggere la documentazione di base per poterle utilizzare. È probabile invece che le maggiori librerie standard siano già presenti nel proprio computer.

Files di intestazione di uso frequente

Ci sono alcuni files di intestazione specifici per il compilatore FreeBASIC che capiterà spesso di dover includere nei propri progetti. Ecco di seguito una breve lista:

  • datetime.bi (per lavorare con le date e le ore)
  • dir.bi (per lavorare con le cartelle)
  • file.bi (per lavorare con i files)
  • fbgfx.bi (per lavorare con la grafica)
  • string.bi (per lavorare con la formattazione delle stringhe)

Nel prossimo articolo vedremo come creare una libreria statica.