PDA

Visualizza la versione completa : [C++] Funzioni?!?


Iena87
05-04-2004, 00:04
Dunque sto seguendo la guida al C++ proposta sul sito di HTML ed arrivato alla sezione sulle funzioni c'è una cosa che mi è parsa poco chiara:

Alla pagina http://programmazione.html.it/cplusplus/cplusplus_14.htm dice:
Il tipo restituito indica appunto il tipo del valore restituito dalla funzione. Il nome_funzione può essere un nome qualunque scelto per descriere lo scopo della funzione. Se la funzione riceve parametri, sarà necessario specificare il tipo_argomento seguito da un nome_argomento. Anche il tipo degli argomenti può essere void, int, float, ecc.. Se a una funzione si passano più argomenti, questi dovranno essere separati da una virgola. e fin qui tutto chiaro, anche se nn avevo capito inzialmente la frase "Se a una funzione si PASSANO più argomenti....." , causa la parola passano, che probabilmente vorrà significare che se in una funzione sono interessate + variabili, questo deve essere indicato nella definizione del prototipo, anche se gradirei una vostra illuminazione sull'argomento perchè mi sa che nn ho capito affatto il significato.

Cmq nn è questo il mio problema maggiore, infatti nn ho capito in particolare questa cosa: nel link postato viene illustarta una funzione che esegue una moltiplicazione tra due valori costanti di due variabili (a e b) e restituisce tale moltiplicazione in un'altra variabile (risultato), e poi la visualizza.....ma come ha fatto a capire che si tartta proprio di una moltiplicazione????
cioè non è stata eseguit alcuna azione che specifichi che moltiplicazioni esegua proprio una moltiplicazione.....nn so se sono stato chiaro ma spero che mi abbiate capito e mi possiate dire cosa bisogna scrivere per associare alla funzione moltiplicazione un'operazione di moltiplicazione


Grazie in anticipo :)

LeleFT
05-04-2004, 00:23
Ehm... a me sembra che in quella parte della guida venga semplicemente illustrato come definire il prototipo di una funzione ed i vari tipi di passaggio dei parametri.

Se noti, la funzione non è per nulla implementata, né, tantomeno, l'intero main().

In quelle pagine viene solo illustrato come definire una funzione (ossia come dichiararla), non come scriverla, né come far restituire un risultato. (tra l'altro ci sono paercchi errori in quel codice)

Il codice alla fine, sarà qualcosa del tipo:


#include <iostream.h>

// Definizione del prototipo (secondo me è più chiaro se messo qui questo commento)
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
}

int moltiplica(int x, int y) {
return x * y;
}


Ciao. :ciauz:

Iena87
05-04-2004, 00:33
ma primo scrivo :

risultato=moltiplica(a,b)
cout << "Il risultato della moltiplicazione è: " << risultato << endl


e poi dopo:

int moltiplica(int x, int y) {
return x * y;
}

:confused:

Proprio nn ci ho capito nulla :(
Ma nn dovrebbe stare scritto prima come si calcola e poi dopo si effettuano i calcoli e si visualizza??

LeleFT
05-04-2004, 00:42
Calma... moltiplica() è una funzione.
Può essere implementata in due posti differenti: prima del main() o dopo del main(). La differenza stà nel fatto che, se la implemento dopo (come nel mio caso), devo prima dichiararla scrivendone il prototipo prima del main.

In alternativa posso scriverla prima del main e, così facendo, non serve dichiararne il prototipo.

Una funzione è un sottoprogramma che viene richiamato quando si fa uso del suo nome: nel codice c'è scritto:


risultato = moltiplica(a,b);

Quando il programma viene eseguito ed arriva a quella riga, automaticamente viene richiamata la funzione moltiplica, il cui corpo è implementato dopo. Non ha importanza, dal punto di vista intuitivo, dove viene scritta una funzione, l'importante è capire che quando essa viene richiamata, vengono eseguite le istruzioni che sono state scritte all'interno del suo corpo.


Ciao. :ciauz:

Iena87
05-04-2004, 01:00
Per chiarirmi le cose potresti scrivere due programmi che eseguano la moltiplicazione attraverso funzione.....così vedo le differenze che vi sono.....possibilimente (anzi ti prego) potresti scriverli completi con tanto di librerie, dichiarazione di variabili e quant'altro ??? così capisco ancora meglio :)
e Grazie mille per tutto :)

LeleFT
05-04-2004, 14:10
Ok... questo è il programma che esegue la moltiplicazione richiamando la funzione moltiplica passandogli i due operandi, senza dichiarazione del prototipo:


#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:


#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:


a * b

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:


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. :ciauz:

Iena87
06-04-2004, 20:45
Originariamente inviato da LeleFT
Ok... questo è il programma che esegue la moltiplicazione richiamando la funzione moltiplica passandogli i due operandi, senza dichiarazione del prototipo:


#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:


#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:


a * b

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:


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. :ciauz:



Nn posso fare altro che ringraziarti immensamente :)

Iena87
12-04-2004, 01:14
Dunque le funzioni le ho capite bene, l'overloading ecc anche, ma il passaggio di array a funzioni proprio no...forse mi sbaglio, ma la guida sul sito fornisce un esempio che non è proprio tanto chiaro, eccolo:


/*
*Un semplice programma che illustra il passaggio
*di un array ad una funzione
*/

#include <iostream.h>
#define SIZE 5;

void somma(int array[ ])
{
int i;
int somma = 0;

for(i=0; i < SIZE; i++)
{
somma = somma + array[i];
}
cout << " La somma degli elementi dell'array è " << somma << "\n";
}

main( )
{
int vettore[SIZE] = {1,2,3,4,5};

somma(vettore);
return(0);
}


Potreste farmi un esempio più chiaro su tale argomento????
Grazie mille in anticipo :)

scancode
12-04-2004, 02:08
ok

Iena87
12-04-2004, 13:09
Originariamente inviato da scancode
ok

Bene, aspetto presto la tua risposta :)

Loading