Parametri per valore o per riferimento

Nell’esempio precedente, gli argomenti sono stati passati alla funzione per valore. Quando il passaggio dei parametri avviene per valore, alla funzione viene in effetti passata solo una copia dell’argomento. Grazie a questo meccanismo il valore della variabile nel programma chiamante non viene modificato.

Il passaggio di parametri per valore è un modo molto comune per passare informazioni a una funzione ed è anche il modo normalmente utilizzato in C++.

In passaggio di parametri per riferimento (o reference), alla funzione viene passato l’indirizzo e non il valore dell’argomento. Questo approccio richiede meno memoria rispetto alla chiamata per valore, e soprattutto consente di modificare il valore delle variabili che sono ad un livello di visibilità (scope) esterno alla funzione o al metodo.

Passaggio di parametri per indirizzo

Prima di affrontare il passaggio per riferimento, ci aiuterà esaminare un altro modo per passare gli argomenti ad una funzione: quello del passaggio per indirizzo, molto simile a quello per riferimento, in cui è necessario passare alla funzione degli argomenti di tipo puntatore.

Un vantaggio in più del passaggio per indirizzo rispetto a quello per valore è che la variabile può restituire più di un valore. Facciamo subito un esempio in cui riproponiamo la funzione che calcola la moltiplicazione tra due numeri ma con i parametri passati per indirizzo.

#include <iostream.h>
using namespace std;
// Definizione del prototipo
int moltiplica(int* x, int* y);
main()
{
int a = 5;
int b = 6;
int risultato;
risultato = moltiplica(&a, &b);
cout << Il risultato della moltiplicazione è: << risultato <<endl;
return (0);
}
// Dichiarazione della funzione
int moltiplica(int* x, int* y)
{
int ris;
// effettua la moltiplicazione tra i valori che si
// trovano leggendo il contenuto della memoria
// agli indirizzi x e y, tramite il prefisso '*'
// (da non confondere con l'operatore di moltiplicazione)
ris = *x * *y;
// Valore restituito dalla funzione.
return ris;
}

Passaggio di parametri per riferimento

Il tipo reference è un puntatore ad un indirizzo di memoria, ma non richiede l’uso di un operatore di indirizzamento (il prefisso asterisco ‘*’ per intenderci).

La sintassi che stiamo per osservare semplifica l’uso delle variabili puntatore nelle chiamate alle funzioni. Si capisce immediatamente confrontando il codice dell’esempio precedente con quello che segue:

#include <iostream.h>
using namespace std;
// Definizione del prototipo
int moltiplica(int &x, int &y);
main()
{
int a = 5;
int b = 6;
int risultato;
risultato = moltiplica(a, b);
cout << Il risultato della moltiplicazione è: << risultato <<endl;
return (0);
}
// Dichiarazione della funzione
int moltiplica(int &x, int &y)
{
int ris;
// moltiplica ciò che trova presso gli indirizzi di memoria di x e y
// ma non c'è bisogno di esplicitarlo
ris = x * y;
// Valore restituito dalla funzione
return ris;
}

Void, funzioni …senza ritorno

È utile ricordare che in C++ possono tranquillamente esistere funzioni che non prendono nessun argomento e/o che non restituiscono alcun valore. A qualcuno queste ultime ricorderanno le “procedure” del Pascal: ovvero subroutine di codice che non restituivano alcun valore. In C++, le definiamo semplicemente stabilendo che tipo restituito dalla funzione sia void. Esempio:

void stampaCiao()
{
cout <<"Ciao" <<endl;
}