Ok... questo è il programma che esegue la moltiplicazione richiamando la funzione moltiplica passandogli i due operandi, senza dichiarazione del prototipo:
codice:
#include <iostream.h>
/* Qui definisco la funzione moltiplica che prende in input
* i due operandi interi. moltiplica: N x N --> N
* moltiplica(2, 3) = 2 * 3 = 6
*/
int moltiplica(int x, int y) {
int prodotto; // la variabile che conterrà il prodotto
prodotto = x * y; // eseguo la moltiplicazione
return prodotto; // ritorno il risultato
}
/* Questo è il blocco principale del programma */
main()
{
int a = 5; // Dichiaro una variabile e la inizializzo con 5
int b = 6; // Dichiaro una variabile e la inizializzo con 6
int risultato; // La variabile che riceverà il valore di a * b
// quindi varrà 5 * 6, quindi varrà 30
risultato = moltiplica(a, b); // richiamo la funzione e gli dico di
// salvarmi il valore del prodotto nella
// variabile 'risultato'
cout << "Il risultato della moltiplicazione è: " << risultato << endl;
}
Questo sotto è lo stesso programma, dove però il programmatore preferisce scrivere prima il il blocco principale del programma, poi tutte le funzioni che esso usa. In questo caso bisogna dichiarare il prototipo delle funzioni che si intende implementare dopo averle usate:
codice:
#include <iostream.h>
/* Qui definisco il prototipo della funzione moltiplica()
* praticamente dico che dichiaro una funzione, ma la implemento
* successivamente. Serve a far capire al compilatore che la funzione
* da qualche parte esiste, solo che non è definita qui.
*/
int moltiplica(int x, int y);
/* Questo è il blocco principale del programma */
main()
{
int a = 5; // Dichiaro una variabile e la inizializzo con 5
int b = 6; // Dichiaro una variabile e la inizializzo con 6
int risultato; // La variabile che riceverà il valore di a * b
// quindi varrà 5 * 6, quindi varrà 30
risultato = moltiplica(a, b); // richiamo la funzione e gli dico di
// salvarmi il valore del prodotto nella
// variabile 'risultato'
cout << "Il risultato della moltiplicazione è: " << risultato << endl;
}
/* Qui definisco la funzione moltiplica che prende in input
* i due operandi interi. moltiplica: N x N --> N
* moltiplica(2, 3) = 2 * 3 = 6
*/
int moltiplica(int x, int y) {
int prodotto; // la variabile che conterrà il prodotto
prodotto = x * y; // eseguo la moltiplicazione
return prodotto; // ritorno il risultato
}
Come vedi i due programmi sono molto simili... sono praticamente identici, differiscono solamente per la posizione in cui la funzione moltiplica() viene effettivamente implementata.
Nel primo caso la implemento prima di usarla (la uso dentro al main, ma la implemento prima del main), nel secondo, invece, uso la funzione dentro al main, ma la implemento dopo il main. Per fare questo devo dire al compilatore che userò la funzione moltiplica() ma che la implementerò più avanti nel codice.
Da quello che ho capito leggendo il tuo primo post sembra che tu non abbia capito perfettamente cosa sono i parametri di una funzione.
Nel nostro caso, la funzione moltiplica() prende 2 parametri interi. Essi sono gli operandi della funzione, ossia i valori su cui la funzione lavorerà e che possono variare, di volta in volta, richiamando più volte la funzione. E' chiaro che la funzione di moltiplicazione lavora su due operandi... in matematica si scrive:
per indica il prodotto di 'a' per 'b'. In programmazione questo può essere fatto nel modo visto sopra: si dichiara una funzione dandogli un nome (possibilmente significativo) e gli si dicono quali sono i valori su cui lavorare (i parametri), che nel nostro caso sono i due operandi.
C'è da fare attenzione a non confondere i parametri di una funzione, con le variabili che essa usa. Una funzione può usare un numero svariato di variabili (per esempio, come nel nostro caso, per salvarsi dei risultati intermedi, per fare delle elaborazioni, magari su valori costanti come PI greco, numero di Nepero, ecc.), ma esse sono un SOPRAINSIEME di tutti i parametri ad essa passati. Questo significa che i parametri passati ad una funzione sono, per la funzione, delle variabili su cui lavorare, ma non necessariamente TUTTI e SOLI, anzi! Il più delle volte è necessario usufruire di ulteriori variabili per poter salvare dei risultati intermedi.
Prendi come esempio la funzione che calcola il resto della divisione fra due numeri. Essa lavora solamente su 2 parametri, ma per la computazione ha bisogno di una terza variabile in cui salvare un risultato intermedio:
codice:
int resto(int dividendo, int divisore) {
int quoziente; // Variabile in cui salvare, temporaneamente, il valore del quoziente
int risultato; // può essere omessa, facendo tutti i conti su una sola riga
quoziente = (int) dividendo / divisore;
risultato = dividendo - (quoziente * divisore);
return risultato;
}
Spero, con questo, di averti chiarito un po' le idee. Soprattutto la differenza fra gli argomenti di una funzione (i parametri, i valori sui quali operare) e le variabili che essa usa.
Ciao. 
Rispondi quotando
