Passaggio dei parametri
All'atto della chiamata di un sottoprogramma è possibile specificare dei parametri.Prima dell'esecuzione del codice del sottoprogramma B avviene un passaggio, assegnazione, del valore di x in alfa e del valore di y in beta.
Il sottoprogramma B svolgerà l'operazione per la quale è stato progettato in modo parametrico, cioè in funzione dei valori assunti dai parametri formali (alfa, beta, ...) specificati dal chiamante A tramite i parametri attuali (x, y, ...)
Chi non ha scritto personalmente il codice può immaginare il sottoprogramma come uno strumento del quale conosce il nome, l'elenco dei parametri formali e la funzionalità che offreLa modalità di passaggio dei parametri dipende dal linguaggio adottato
| Basic |
Sub XYZ(ByVal alfa As Integer, ByVal beta As Double)
|
|---|---|
| Pascal |
Procedure XYZ(alfa: Integer; beta: Double);
|
| C... |
void XYZ(int alfa, double beta)
|
Note
- l'elenco dei parametri attuali deve corrispondere in numero e tipo all'elenco dei parametri formali
- ogni parametro formale viene dichiarato e si comporta come una variabile locale inizializzata al valore specificato con il parametro attuale all'atto della chiamata
- i parametri attuali devono essere valori, quindi possono essere costanti (-1, +5.0), variabili (x, y), espressioni (-x, y+5.0), ...
- al termine dell'esecuzione del sottoprogramma le eventuali modifiche dei valori dei parametri formali scompariranno per sempre...
Passaggio per riferimento
Piuttosto che passare dei valori si può scegliere di passare delle variabili.Il sottoprogramma B svolgerà l'operazione per la quale è stato progettato utilizzando x, il parametro attuale, ogni volta che nel suo codice compare alfa, il parametro formale.
Si dice che alfa è solo un reference, riferimento, per x.
Analogamente per y e beta.
| Intestazione | Chiamata | |
|---|---|---|
| Basic |
Sub XYZ(ByRef alfa As Integer, ByRef beta As Double)
Sub XYZ(alfa As Integer, beta As Double) |
Call XYZ(x, y)
|
| Pascal |
Procedure XYZ(Var alfa: Integer; Var beta: Double);
|
XYZ(x, y);
|
| C |
void XYZ(int *alfa, double *beta)
|
XYZ(&x, &y);
|
| C++ |
void XYZ(int &alfa, double &beta)
|
XYZ(x, y);
|
Note
- i parametri attuali devono essere variabili
- Basic applica di default la modalità ByRef
- C++ aggiunge una sintassi semplificata rispetto a quella adottata in C
- Java non prevede il passaggio dei parametri per riferimento
Le due modalità possono essere utilizzate contemporaneamente...| Intestazione | Chiamata | |
|---|---|---|
| Basic |
Sub XYZ(ByVal alfa As Integer, ByRef beta As Double)
Sub XYZ(ByVal alfa As Integer, beta As Double) |
Call XYZ(x, y)
|
| Pascal |
Procedure XYZ(alfa: Integer; Var beta: Double);
|
XYZ(x, y);
|
| C |
void XYZ(int alfa, double *beta)
|
XYZ(x, &y);
|
| C++ |
void XYZ(int alfa, double &beta)
|
XYZ(x, y);
|
