--------[FUNZIONI E PASSAGGI DI PARAMETRI PER VALORE E PER RIFERIMENTO]------
Autore: cH!cus
eMail: thechicus@gmail.com
web: http://thechicus.nigx.net
============
LE FUNZIONI
============
Prima di inziare voglio intrudurre un minimo concetto di funzione per chi non
ne sia a conoscenza. Le funzioni sono strumenti presenti in molti linguaggi
di programmazione che permettono il riuso del codice e il risparmio di codice
analogo all'interno del programma. Esse contengono istruzioni che vengono
eseguite ogni tal volta che viene chiamata la funzione in riguardo. Le
funzioni (parlando per quanto riguarda il C/C++) possono tornare un valore
oppure no (void). Quando si chiama una funzione all'interno del programma, a
seconda di come è strutturata la funzione e a seconda del suo scopo, essa
puo' richiedere che gli vengano passati dei valori da usare all'interno della
funzione. Questi valori si chiamano PARAMETRI. Le funzioni in genere
ammettono uno o piu parametri, ma possono anche non richiederne nessuno. Ecco
un'esempio di funzione....
-----------------------------------code--------------------------------------
int Somma(int a, int b) {
return a + b;
}
-----------------------------------end---------------------------------------
La funzione sopra è estremamente semplice quanto inutile. Non fa altro che
fare la somma di due valori interi passatogli come parametri. Essa potrebbe
essere applicata in un programma del genere...
-----------------------------------code--------------------------------------
#include <stdio.h>
int Somma(int x, int y) {
return x + y;
}
int main() {
int a = 6, b = 4, somma;
/* Ecco che compare la funzione */
somma = Somma(a, b);
/* Una volta sommati i due valori ne viene mostrato il risultato */
printf("a+b=%d\n", somma);
return 0;
}
-----------------------------------end---------------------------------------
L'inutilità in questo programma è massima, quasi mi prenderei per il culo da
solo se non lo facessi per spiegare le funzioni XD.
========================
PASSAGGIO DEI PARAMETRI
========================
Abbiamo visto che cos'è una funzione, approsimativamente com'è strutturata e
come la si richiama. Un concetto importante per quanto riguarda tutto il
panorama delle funzioni è il passaggio dei parametri (alle funzioni :D). Il
passaggio dei parametri alle funzioni puo' avvenire in due modi diversi, ed
ognuno di questi modi provoca risultati "diversi". Il passaggio dei parametri
puo' avvenire per VALORE, oppure puo' avvenire per RIFERIMENTO (o indirizzo).
PASSAGGIO PER VALORE
---------------------
Iniziamo con lo spiegare cosa si intende per passaggio dei parametri per
valore. Andate a vedere il codice sopra. Osservate la funzione e il modo con
cui è chiamata nel main. Bene... questo è un'esempio di passaggio per valore.
Che cosa significa? Significa che quando noi passiamo come parametri A e B la
funzione legge cosa c'è dentro i parametri passati, poi li COPIA dentro le
variabili interne alla funzione che li usa per sommarli, e infine restituire
il risultato della somma.
PASSAGGIO PER RIFERIMENTO
--------------------------
Qui il discorso cambia. Questo tipo di passaggio dei parametri non ha niente
a che fare con il passaggio per valore, infatti qui non si copiano i valori,
"ma si fa riferimento ad essi". Cosa vuol dire? Vuol dire che tramite
puntatori si accede direttamente alla memoria delle variabili e se ne
modifica il contenuto, questo grazie anche all'operatore & (AND) che messo
davanti ad'uno variabile ne genera l'indirizzo di dove è collocata in memoria
(infatti una volta che si sa l'indirizzo della variabile essa la si puo' far
puntare da un puntatore). Per spiegarvi la pratica vi propongo una nuova
funzione (la funzione di prima non va bene per spiegare questo :P).
-----------------------------------code--------------------------------------
void Swap(int a, int b) {
int temp;
temp = a;
a = b;
b = temp;
}
-----------------------------------end---------------------------------------
Bene questa funzione non fa altro che scambiare il valore di A e di B. Se A =
5 e B = 10 dopo aver chiamato la funzione si avrebbe A = 10 e B = 6, capito?
Bene, a regola lo scopo sarebbe quello... ma c'è un'intoppo! Guardate bene la
funzione. Si nota subito che la funzione non torna valori, o in gergo si dice
VOID. Abbiamo anche detto che le funzioni, se scritte come fino ad adesso le
abbiamo viste, LEGGONO i valori dai parametri passai e gli copiano
all'interno della funzione per essere elaborate. Ma la nostra ultima funzione
gli deve scambiare ed con il passagio dei parametri per valore è impossibile,
perchè una volta terminata la funzione i valori di A e B rimangono uguali. Lo
scambio dei valori avviene solamente dentro la funzione! non fuori! e a noi
interessa che venga fuori! Come ovviare? Ecco la soluzione...
-----------------------------------code--------------------------------------
void Swap(int *pa, int *pb) {
int temp;
temp = *pa;
*pa = *pb;
*pb = temp;
}
-----------------------------------end---------------------------------------
Cosa abbiamo cambiato? Cosa sono quegli asterischi davanti alle variabili?
Un'asterisco davanti ad una variabile sta ad indicare che quella variabile è
un puntatore. Ad un puntatore come ho detto prima gli si fa puntare
l'indirizzo di una variabile, e una volta fatto questo modificando il
puntatore si modifica anche la variabile puntata da esso. La funzione adesso
è pronta, è un semplice esempio di funzione dove i parametri devono essere
passati per riferimento. Adesso che abbiamo fatto la funzione facciamo il
programma che la usi.
-----------------------------------code--------------------------------------
#include <stdio.h>
int main() {
int a = 6; b = 9;
printf("Prima:\na=%d\tb=%d\n\n", a, b);
/* Ecco la chiamata. */
Swap(&a, &b);
printf("Dopo la funzione Swap:\na=%d\tb=%d\n\n", a, b);
return 0;
}
-----------------------------------end---------------------------------------
Notare che le variabili passate per parametri davanti a se hanno tutte e due
l'operatore &, questo non per indicare il loro valore, ma per indicare il
loro indirizzo. La funzione Swap una volta chiamata e una volta in possesso
dell'indirizzo delle variabili passate fa il suo lavoro senza problemi.
Infatti nel programma le variabili prima della chiamata della funzione Swap
hanno dei valori, ma dopo la chiamata i valori sono scambiati. Provare per
credere! :D
Per adesso è tutto, spero di esservi stato utile!
ciao!
cH!cus
Aggiungi un commento