Embedded Files
Le funzioni sono parti di un programma che consentono di modularizzare e strutturare il codice.
In altri termini, quando in un algoritmo è possibile individuare delle parti che hanno un'autonomia funzionale (ad esempio l'estrazione di una radice quadrata, la risoluzione di un'equazione di secondo grado ecc.), è possibile e conveniente implementare queste parti del programma in parti separate opportunamente organizzate, le funzioni.
Queste ultime hanno la caratteristica di poter ricevere dei parametri in input e di poter restituire un valore.
La definizione di una funzione avviene con un blocco di istruzioni che ha la seguente forma:
int nome_funzione(int parametro1, int parametro2)
{
...
return valore;
}
tipo (in rosso): è anteposto al nome della funzione e stabilisce il tipo di valore restituito dalla funzione. Esempi di tipo sono:
int: il valore restituito è un intero
float: il valore restituito è un numero con la virgola
void: la funzione non restituisce nessun valore
nome_funzione (in blu): è una stringa alfanumerica senza spazi
int parametro1, int parametro2 (in viola): è una lista di parametri separati da virgole. Ogni parametro è caratterizzato da un tipo. E' possibile definire una funzione senza parametri, in questo caso la funzione avrà una forma del tipo int nome_funzione()
return (in verde): la funzione deve terminare richiamando l'istruzione return per restituire un valore coerente con il tipo della funzione. Nel caso particolare in cui la funzione è di tipo void (cioè se non restituisce alcun valore) l'istruzione return non deve essere accompagnato da nessun valore.
Eventuali variabili dichiarate in una funzione sono del tutto indipendenti dalle variabili dichiarate nel main. Anche in caso di omonimia le variabili sono trattate in modo del tutto indipendente.
Esempio:
Il seguente esempio mostra un programma che fa uso di 4 funzioni.
#include <stdio.h>
// Calcola la potenza x^n
int potenza(int x, int n)
{
int i, ret;
ret = 1;
for (i=0; i<n; i++)
ret=ret*x;
// in uscita dal for ret contiene x^n
return ret;
}
// Stampa una cornice iniziale
void header()
{
printf("*************************************\n");
printf("* INIZIO PROGRAMMA *\n");
printf("*************************************\n\n");
return;
}
// Stampa una cornice finale
void footer()
{
printf("\n\n");
printf("*************************************\n");
printf("* FINE PROGRAMMA *\n");
printf("*************************************\n");
return;
}
// Calcola il prossimo numero pari
// se il numero passato è negativo restituisce -1
int prossimo_pari(int x)
{
if (x<0)
return -1;
else if (x%2==0)
return x+2;
else
return x+1;
}
int main()
{
int p, x;
header();
// p = 5^3
p=potenza(5,3);
printf("5^3=%d\n", p);
// p = 2^4
p=potenza(2,4);
printf("2^4=%d\n", p);
printf("Inserire un numero x: ");
scanf("%d", &x);
p=prossimo_pari(x);
printf("Prossimo numero pari successivo a %d = %d\n", x, p);
printf("Inserire un numero x: ");
scanf("%d", &x);
p=prossimo_pari(x);
printf("Prossimo numero pari successivo a %d = %d\n", x, p);
footer();
return 0;
}
La seguente immagine mostra un'esecuzione del programma.
int potenza(int x, int n)
{
...
return ret;
}
potenza è la prima funzione definita nel programma. Osserviamo quanto segue:
Posizione nel file sorgente: la definizione è fatta dopo le direttive #include e prima del main()
Valore di ritorno: la funzione restituisce un valore di tipo intero, tale valore è restituito in corrispondenza dell'istruzione return. Il valore restituito, in questo esempio, è il valore della variabile ret
Parametri: i parametri della funzione sono x e n. All'interno della funzione i parametri sono utilizzati come qualsiasi variabile, ma non vanno inizializzati. Il valore assunto dai parametri dipende dal valore passato alla funzione al momento dell'invocazione (vedi oltre).
void header()
{
...
return;
}
La funzione header non ha parametri e non restituisce nessun valore.
Notare che dopo il nome della funzione compare una coppia di parentesi senza alcun contenuto: le parentesi devono essere sempre presenti, anche se la funzione non ha parametri.
L'istruzione return non è seguito da nessuna variabile o valore perché la funzione è di tipo void.
int prossimo_pari(int x)
{
...
}
La funzione prevede un solo parametro e restituisce un intero.
Notare che all'interno della funzione è presente più volte l'istruzione return:
return -1;
return x+2;
return x+1;
In corrispondenza dell'istruzione return la funzione termina e restituisce un valore.
int main()
{
...
header();
...
p=potenza(5,3);
...
p=potenza(2,4);
...
p=prossimo_pari(x);
...
p=prossimo_pari(x);
...
footer();
return 0;
}
Nel main() è possibile richiamare le funzioni precedentemente definite tramite il loro nome.
Questa operazione è detta invocazione della funzione.
Osserviamo quanto segue:
Invocazione della funzione header(): quando il flusso del programma giunge in corrispondenza dell'istruzione header() il controllo passa alla funzione e viene eseguito il codice in essa presente. In questo caso è stampato il riquadro con la scritta INIZIO PROGRAMMA. In corrispondenza dell'istruzione return il controllo ritorna al main e riprende dall'istruzione successiva.
Invocazione della funzione potenza(5, 3): questa funzione prevede due parametri di tipo intero, questo significa che all'invocazione devono essere passati due numeri (o variabili) di tipo intero. In corrispondenza dell'invocazione potenza(5, 3) il primo parametro della funzione riceve il valore 5 e il secondo il valore 3. Quando il controllo passa alla funzione, i parametri x e n sono utilizzati come normali variabili, i cui valori sono rispettivamente 5 e 3. In corrisponde dell'istruzione return ret la funzione assume il valore indicato dalla variabile ret e il controllo ritorna al main. L'istruzione p=potenza(5,3) prevede che il valore assunto dalla funzione sia assegnato alla variabile p, in questo esempio il valore 125.
Invocazione della funzione potenza(2, 4): in corrispondenza di questa invocazione i parametri x e n della funzione assumono i valori 2 e 4. Il valore assunto dalla funzione sarà 16 e verrà assegnato alla variabile p.
Invocazione della funzione prossimo_pari(x): questa funzione prevede un solo parametro e quindi il valore assunto dalla variabile x al momento dell'invocazione è trasferito al parametro della funzione. Non vi è alcun collegamento tra il nome della variabile utilizzato al momento dell'invocazione e il nome del parametro utilizzato nella definizione della funzione: l'omonimia tra la variabile x presente nel main e il parametro x delle funzione non crea alcuna problema perché le due variabili sono trattate come variabili del tutto indipendenti.
Invocazione della funzione footer(): la funzione footer(), analogamente alla funzione header, non prevede parametri e non restituisce valori.
Sito: 7ecnologie
Sezione: 08. C language
Capitolo: 02. Introduzione al C
Paragrafo: 14. Definizione di funzioni
Indice dei capitoli: 00. Risorse - 01 Ambiente di sviluppo - 02. Introduzione al C - 03. Le librerie - 04. Tutorial - 05. Esercizi svolti - 98. Esercizi
Indice dei paragrafi: 01. Hello World - 02. Variabile di tipo int - 03. Input da tastiera - 04. Controllo condizionale if - 05. Operatori logici - 06. Ciclo while - 07. Operatore modulo - 08. Array - 09. Ciclo for - 10. Ciclo do/while - 11. Variabili di tipo float - 12. Funzione random() - 13. Impostazione del set di caratteri - 14. Definizione di funzioni - 15. Passaggio di parametri: gli array - 16. Variabili: visibilità e durata - 17. Il tipo char - 18. I file - 19. Funzioni matematiche
Indice degli approfondimenti: 01. Es. svolto: MCD - 02. Es. svolto: Cifra
Page updated
Google Sites
Report abuse