FreeBASIC – costante

In questo articolo faremo la conoscenza delle costanti.

In determinate circostanze è molto utile nella programmazione ricorrere all’uso di una o più costanti.

Per esempio se in più punti del nostro codice dobbiamo utilizzare il valore del Pi greco, è bene definire una costante, non avrebbe senso infatti definire una variabile in quanto il Pi greco è una nota costante matematica:

const pi_greco = 3.14159 ''la dichiarazione del tipo è opzionale

Una volta definita una costante non sarà più possibile cambiarne il valore nel codice, pena l’incorrere in un errore in fase di compilazione.

La cosa bella delle costanti è che hanno un ambito globale (global scope): ovvero possiamo utilizzare il loro nome, e quindi il loro valore, anche tra moduli diversi dello stesso programma.

Ovviamente siamo liberi di definire costanti numeriche, booleane o stringa:

const sconto as integer = 20
const stato as boolean = true
const etichetta as string = "SCONTO"

Se non viene dichiarato esplicitamente il tipo di costante, questo viene comunque inferito dal compilatore.

Nel prossimo articolo parleremo delle variabili.

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:

tutte le variabili numeriche con capacità più piccola di quella del tipo integer vengono convertite nel tipo integer;
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);
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.

FreeBASIC – tipi di files

Vi avverto: questo sarà un articolo abbastanza noioso, ma, allo stesso tempo, anche indispensabile per affrontare con più consapevolezza la programmazione in FreeBASIC.

Cominciamo.

Dovete sapere che in FreeBASIC ci sono tre tipologie di files. Due delle quali abbastanza scontate, ma la terza… che dire… è un po’ strana.

I. File sorgente (o modulo)

Questi files contengono il nostro codice sorgente e hanno estensione .bas. Un semplice programma può essere scritto interamente anche in un solo file, ma se il programma che stiamo sviluppando è di una certa complessità, allora è preferibile organizzarlo su più files sorgente.

II. File eseguibile

Il processo di compilazione crea un file eseguibile contenente sia il codice oggetto ricavato a partire da uno o più files di codice sorgente, che eventuali collegamenti a una o più librerie. Negli ambienti Windows questi files hanno estensione .exe.

III. File di intestazione

Eccoci arrivati al terzo tipo di file, quello strano.

Abbiamo detto che quando ci troviamo a dover sviluppare un programma complesso è bene organizzarlo in più files di codice sorgente. Ebbene, in questi casi, è spesso conveniente anche scrivere un particolare tipo di file sorgente che viene appunto chiamato file di intestazione e che ha come estensione .bi. Questo particolare file contiene generalmente soltanto alcuni specifici tipi di informazioni, quali, per esempio:

dichiarazioni di variabili o costanti
definizioni di funzioni
…

La presenza di questo tipo di file aiuta i programmatori ad avere una visione complessiva delle variabili, delle costanti, delle funzioni, ecc., che possono essere utilizzate senza dover prendere visione ogni volta di tutti i files sorgente.

Incastrare tutti i pezzi come in un puzzle

Per utilizzare più files sorgenti o più files di intestazione occorre includerli nel file sorgente che si sta scrivendo attraverso la direttiva #include che informa il compilatore FreeBASIC sul percorso e sul nome della risorsa da includere durante il processo di compilazione.

Nota: un file di intestazione può a sua volta includere altri files di intestazione.

Avendo a che fare con un grande progetto contenente molti files sorgente (magari non tutti scritti da noi), e magari anche più files di intestazione, potrebbe capitare il caso che più files contengano una direttiva di inclusione per la stessa risorsa. Onde evitare un lavoro inutile al compilatore è bene utilizzare la direttiva #include in questa sua variante:

#include once "percorso e nome della risorsa"

Riguardo alla scrittura del percorso, ovvero della sequenza delle cartelle sino ad arrivare a quella che contiene la nostra risorsa, è bello sapere che:

Il compilatore FreeBASIC converte in automatico i simboli di separazione delle cartelle (la barra / negli ambienti Linux, la barra rovesciata \ negli ambienti Windows) in base al sistema operativo dove viene utilizzato.

Evviva! Ce l’abbiamo fatta.

La prossima settimana daremo uno sguardo nel magico mondo delle librerie. 🙂

FreeBASIC – do-loop

Dopo aver visto come funziona l’istruzione for-next, oggi facciamo la conoscenza di una seconda struttura di controllo dedicata sempre alla iterazione: l’istruzione do-loop.

Sintassi

do [ { until | while } condizione ]
    [blocco istruzioni]
loop

oppure:

do
    [blocco istruzioni]
loop [ { until | while } condizione ]

Semantica

Le due modalità di scrittura dell’istruzione differiscono nel fatto che, nella seconda tipologia, il blocco di istruzioni viene eseguito almeno una volta.

Utilizzando la parola-chiave until, il ciclo si ripete fino a che (until) la condizione assume valore vero (true), una volta che questo accade si esce dal ciclo.

Con la parola-chiave while, invece, il ciclo si ripete mentre (while) la condizione ha valore vero (true); quando la condizione assume valore falso (false) il ciclo si interrompe.

Esempio

dim c as integer
c = 0
'il ciclo stampa i numeri da 0 a 9
do while c < 10
    print "Il valore della condizione è pari a: "; c
    c += 1 'incrementa di uno
loop

Nel prossimo articolo parleremo dei diversi tipi di files gestiti dal compilatore FreeBASIC.

FreeBASIC – for-next

Dopo aver parlato della struttura di controllo if-then-else utile per gestire le alternative, oggi incontriamo un’altra struttura di controllo che viene utilizzata per l’iterazione (o ciclo): l’istruzione for-next.

Questa è la sua sintassi:

for iteratore [as tipo dati] = valIniz to valFinale [step valPasso]
  [blocco istruzioni]
next iteratore

In pratica all’inizio del ciclo la variabile iteratore assume il valore valIniz, dopodiché il blocco delle istruzioni viene eseguito sino a che il valore della variabile iteratore non raggiunge il valore valFinale procedendo per passi della lunghezza pari a valPasso:

' stampa il valore della variabile i da 0 a 10 con passo 2
for i as integer = 0 to 10 step 2
    print "La variabile iteratore ora vale: "; i
next i

Alcune cose che è bene sapere:

la variabile iteratore può anche essere dimensionata all’esterno del ciclo;
il passo, oltre a poter assumere valori interi, può anche essere un valore decimale;
se il valore del passo non viene specificato, questo assumerà il valore predefinito 1;
i valori valIniz e valFinale possono essere anche delle espressioni;
il valore valFinale può anche essere minore di valIniz, in questo caso il passo deve avere un valore negativo.

Nel prossimo articolo parleremo di un’altra struttura iterativa, il ciclo do-loop.

FreeBASIC – if-then-else

Nel precedente articolo abbiamo imparato come immettere dati grazie alla istruzione input. Ora che abbiamo questa possibilità e quella di stampare a video delle informazioni, possiamo permetterci di scrivere il nostro primo programma contenente una struttura di controllo: la struttura if-then-else che permette di scegliere tra diverse alternative.

'Programma con struttura di controllo
dim t as string
input "Come ti chiami "; t
if t = "ciuchina" then
    print "Benvenuta "; t
elseif t = "ciuchino" then
    print "Benvenuto "; t
else
    print "Ciao, non ti conosco "; t
end if

Semplice, no? 🙂

Nota anche la presenza di un commento all’inizio del programma.

I commenti sono molto utili per fornire informazioni a chi leggerà il nostro codice, ma anche per noi stessi una volta che andremo a rileggere i nostri programmi a distanza di tempo.

Per inserire un commento su una singola riga basta anteporre il simbolo apice (‘) al testo del nostro commento.

Nel prossimo articolo parleremo di un’altra struttura di controllo adatta a gestire l’ iterazione: l’istruzione for-next.

FreeBASIC – input

Ben ritrovati. 🙂

Dopo aver parlato di come si stampa a video, e aver imparato come si dichiara una variabile, passiamo ora ad analizzare come funziona l’istruzione input.

Questa istruzione permette di leggere una lista di valori immessi da tastiera.

dim as integer a, b
input "Immetti la base e l'altezza separati da una virgola ", a, b
print "L'area del quadrato vale: "; a * b

Se al posto della virgola, subito dopo la frase di richiesta, fosse stato inserito un punto e virgola, allora sarebbe comparso in automatico un punto di domanda alla fine della frase.

Se si immettono meno valori rispetto a quelli attesi, le variabili verranno comunque valorizzate: con zero per le variabili numeriche, e con un testo vuoto nel caso di variabili stringa.

Occorre precisare che la frase è opzionale e la lista delle variabili potrebbe anche ridursi ad una sola variabile:

input a

Immissione di un testo contenente delle virgole

Se abbiamo necessità di inserire una stringa contenente delle virgole, allora possiamo utilizzare l’istruzione line input:

dim t as string
line input "Inserisci un testo con virgole: ", t
print "Hai inserito il testo: "; t

Ci leggiamo al prossimo articolo dove faremo la conoscenza della nostra prima struttura di controllo adatta a gestire quelle situazioni in cui ci troviamo di fronte ad una alternativa: l’istruzione if-then-else 🙂