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;
}