FreeBASIC – procedure

Dopo aver introdotto nel precedente articolo il tipo di dato definito da noi, in questo nuovo articolo faremo la conoscenza delle procedure.

Iniziamo dandone una sintetica definizione:

Una procedura è un blocco di codice che può essere eseguito tramite una chiamata da qualsiasi punto del nostro programma per un numero indefinito di volte.

La stessa definizione ci aiuta a capire che ha senso scrivere una procedura ogni qual volta ci accorgiamo che una specifica sequenza di istruzioni deve essere utilizzata più volte durante la scrittura del nostro programma.

Scrivere infatti una sola volta un blocco di codice, oltre a farci risparmiare tempo, ci evita di dover andare a ripetere lo stesso tipo di correzione, su diversi punti del programma, ogni qual volta ci dovessimo accorgere che una modifica si rende necessaria. Questo aumenta la cosiddetta manutenibilità del codice.

Tipi di procedure

In FreeBASIC ci sono due diversi tipi di procedure:

  1. procedure che non restituiscono alcun valore. In questo caso le si definiscono con il termine inglese subroutines;
  2. procedure che restituiscono un valore. In questo caso le si definiscono più propriamente funzioni.

Subroutine

Per lavorare con una subroutine occorre prima dichiararla con la parola-chiave declare e poi definirla con con la parola-chiave sub.

La dichiarazione assegna un nome (o etichetta) alla procedura, mentre la definizione contiene le vere e proprie istruzioni che dovranno essere eseguite ogni volta che verrà fatta una chiamata con il nome della procedura:

'dichiarazione della procedura
declare sub mia_procedura

'chiamata della procedura
mia_procedura

'definizione della procedura
sub mia_procedura
  print "ciao"
end sub

Come è possibile notare, per poter chiamare una procedura occorre che la chiamata sia successiva alla sua dichiarazione, mentre il corpo della procedura vera e propria può essere scritto sotto alla chiamata o, come più spesso accade, in un file separato.

Funzione

Come abbiamo già detto, una funzione differisce da una semplice procedura per il fatto che la funzione restituisce sempre un valore nel punto esatto dove questa viene chiamata.

Anche una funzione, come avviene per una subroutine, va prima dichiarata assegnandole un nome. Soltanto successivamente va definita attraverso la parola-chiave function. Per la funzione è anche necessario dichiarare il tipo di dato restituito e questo lo si fa all’atto della dichiarazione:

'dichiarazione della funzione
declare function mia_funzione as integer

'dichiarazione di una variabile
dim i as integer

'chiamata della funzione
i = mia_funzione
print i

'definizione della funzione
function mia_funzione as integer
  return 10
end function

Bene. Ora che sappiamo usare anche le procedure possiamo cominciare a scrivere i nostri primi veri programmi procedurali. 😉

A rileggerci al prossimo articolo dove approfondiremo la conoscenza delle procedure affrontando il tema del passaggio di argomenti.

FreeBASIC – tipo di dato definito da noi

Nonostante i tipi di dato standard ci permettano di risolvere la maggior parte dei problemi che affrontiamo quando scriviamo un programma, può verificarsi il caso che si renda utile, se non addirittura necessario, utilizzare un tipo di dato creato ad hoc direttamente da noi.

Anche questo tipo di dato dovrà essere identificato da una etichetta che dovrà rispettare le stesse regole viste per le variabili.

Il tipo di dato creato dall’utente (user-defined type o UDT) può essere visto come una specie di array, con la particolarità che un UDT può contenere anche tipi di dato differenti. È proprio questa caratteristica a rendere utile un UDT.

Un UDT può contenere sia variabili che procedure che prendono il nome di membri (o elementi).

Utilizzo di un UDT attraverso una variabile

Per accedere ai singoli membri attraverso una variabile si utilizza l’operatore . (notazione puntata):

'definizione di un nostro tipo di dato
type automobile
  cavalli as integer
  cilindrata as integer
end type

'dimensionamento e creazione di una variabile
'del tipo appena definito
dim mia_auto as automobile

'valorizzazione dei membri
mia_auto.cavalli = 75
mia_auto.cilindrata= 999

'stampa dei valori
print "CV = "; mia_auto.cavalli
print "Cilindrata = "; mia_auto.cilindrata

Utilizzo di un UDT attraverso un puntatore alla sua variabile

Come abbiamo visto nell’articolo dedicato ai puntatori, anche per i titi di dato definiti da noi (UDT) possiamo creare il relativo puntatore alla sua variabile.

La creazione di questo tipo di puntatore è simile a quella per un puntatore ad una variabile relativa a un tipo di dato standard. Ciò che cambia è la modalità di accesso ai singoli membri che dovrà avvenire attraverso l’operatore ->.

Riprendendo l’esempio precedente, aggiungiamo le seguenti righe di codice:

'creazione di un puntatore alla variabile
dim p as automobile pointer = @mia_auto

'valorizzazione dei membri attraverso il puntatore
p->cavalli = 90
p->cilindrata= 1500

'stampa dei valori
print "CV = "; p->cavalli
print "Cilindrata = "; p->cilindrata

Nel prossimo articolo inizieremo a parlare delle procedure.

A presto. 🙂