Tag: byval

FreeBASIC – ritorno dei valori

Come abbiamo visto nel primo articolo dedicato alle procedure, a differenza delle subroutines le funzioni hanno la particolarità di ritornare uno o più valori una volta che sono state chiamate.

Ciò significa, per esempio, che se scrivo una ipotetica funzione somma in grado di ricevere due argomenti, una volta eseguito il codice all’interno della funzione, questa restituirà al codice chiamante un valore pari alla somma dei due parametri (che possiamo quindi interpretare come addendi).

Ritorno dei valori per valore

Diciamo subito che in FreeBASIC la modalità del ritorno per valore è quella di default.

Non vi è quindi la necessità di specificarla attraverso la parola-chiave byval nella dichiarazione e nella definizione della funzione.

Tipologie di restituzione

Esistono tre differenti tipologie di restituzione dei valori:

'1. usando lo stesso nome della funzione
function semaforo() as string
  [...]
  semaforo = "rosso"
  [...]
end function

'2. usando la parola-chiave function
function semaforo() as string
  [...]
  function = "rosso"
  [...]
end function

'3. usando la parola-chiave return
function semaforo() as string
  [...]
  return "rosso"
end function

La differenza tra queste tre modalità sta nel fatto che nelle prime due, una volta restituito il valore, viene comunque eseguito il resto del codice presente nella funzione, mentre, nel terzo caso, l’esecuzione della funzione termina con la restituzione del valore.

Ritorno dei valori per riferimento

Alle volte potrebbe essere utile avere il riferimento al risultato di una funzione piuttosto che il suo valore.

Avere il riferimento al risultato permette infatti al codice chiamante di modificare successivamente il valore della stessa variabile utilizzata dalla funzione per fornire il risultato conoscendone appunto il suo indirizzo di memoria.

Per scegliere questa modalità di restituzione dei valori è necessario specificarla, sia in fase di dichiarazione che in quella di definizione della funzione, attraverso la parola-chiave byref.

Vediamo un esempio direttamente tratto dalla Guida del programmatore disponibile sul sito ufficiale di FreeBASIC:

'dichiarazione della funzione
declare function minimo(byref i as integer, byref j as integer) byref as integer

'dimensionamento e valorizzazione delle variabili
dim as integer a = 13, b = 7 

'stampa del valore originale delle variabili
print a, b

'stampa del valore minimo
print minimo(a, b)

'modifica del valore della variabile con valore minimo
minimo(a, b) = 0

'stampa del valore delle variabili aggiornato
print a, b

'definizione della funzione
function minimo(byref i as integer, byref j as integer) byref as integer
  if i < j then
    return i
  else
    return j
  end if
end function

Bene. Anche oggi abbiamo fatto un piccolo passo in avanti nella conoscenza del FreeBASIC.

A rileggerci al prossimo articolo. 🙂

FreeBASIC -passaggio di argomenti

Nel precedente articolo abbiamo introdotto il concetto di procedura, sia nella forma di subroutine che di funzione.

In questo nuovo articolo vedremo un aspetto fondamentale che riguarda le procedure: ovvero il passaggio di argomenti:

Quando si chiama una procedura è possibile passarle alcune informazioni attraverso degli argomenti (ovvero variabili od oggetti). All’interno della procedura ci si riferirà a queste informazioni chiamandole parametri.

Per fare in modo che una procedura possa gestire degli argomenti, è necessario che nella sua dichiarazione venga specificata la lista dei parametri. Ciascun elemento di questa lista viene descritto attraverso un nome e la relativa tipologia di dato:

'dichiarazione di una subroutine con lista dei parametri
declare sub scheda (n as string, c as string, e as integer)

'chiamata della subroutine con argomenti racchiusi
'tra parentesi
scheda ("Mario", "Rossi", 182)

'definizione della subroutine
sub scheda (n as string, c as string, e as integer)
  print "nome: "; n
  print "cognome: "; c
  print "età: "; e
end sub

Sebbene in FreeBASIC, quando si chiama una procedura, non è obbligatorio racchiudere gli argomenti tra parentesi, per una migliore leggibilità del codice, soprattutto in presenza di più argomenti, è preferibile utilizzarle.

Sino a questo momento abbiamo parlato genericamente di passaggio di informazioni. Occorre però sapere che in FreeBASIC è possibile passare queste informazioni in due diverse modalità:

  1. passaggio per valore (che in assenza di specifica differente dichiarazione è la modalità di default)
  2. passaggio per riferimento

Vediamo ora di capire bene la differenza tra questi due diversi modi di passare le informazioni.

Passaggio di argomenti per valore (byval)

Abbiamo detto che questa è la modalità di default utilizzata in FreeBASIC.

In pratica quando si passa un argomento per valore, il relativo parametro all’interno della procedura riceve in realtà una copia del valore dell’argomento, e quindi qualsiasi variazione del valore del parametro che potrà avvenire all’interno della procedura non si ripercuoterà sul valore originale dell’argomento.

Ciò significa, per esempio, che se l’argomento è una variabile, il valore di questa variabile rimane inalterato.

Passaggio di argomenti per riferimento (byref)

Se si ha la necessità di fare in modo che le operazioni all’interno di una procedura su un determinato parametro abbiano effetto direttamente sulla variabile, o sull’oggetto passato come argomento in fase di chiamata della procedura, allora è necessario passare questo argomento anteponendo la parola-chiave byref:

'dichiarazione di una variabile
dim a as integer

'dichiarazione della subroutine
declare sub raddoppia (byref n as integer)

'valorizzazione iniziale della variabile
a = 5

'stampa
print "il valore di a prima della chiamata è: "; a

'chiamata della subroutine senza utilizzare le parentesi
raddoppia a

'stampa
print "il valore di a dopo la chiamata è: "; a

'definizione della subroutine
sub raddoppia (byref n as integer)
  n *= 2
end sub

Bene. Per oggi ci fermiamo qui. 🙂

Nel prossimo articolo approfondiremo l’argomento relativo al ritorno dei valori dopo la chiamata di una funzione.