Dichiarazione delle funzioni con i prototipi

Dichiarazione delle funzioni con i prototipi

Le funzioni di un programma C possono comparire in qualsiasi ordine nel file sorgente. Le funzioni devono però essere definite prima che esse vengano utilizzate dal main o da altre funzioni, come è stato fatto negli esempi precedenti.
L’ordine in cui le funzioni sono definite è quindi importante: infatti una funzione non ne può richiamare un’altra se questa non è stata ancora definita.
Il programma sorgente inoltre può essere suddiviso in più file con estensione .c contenenti diverse dichiarazioni di variabili e di funzioni. In fase di compilazione dovranno poi essere specificati tutti i file sorgente che devono essere tradotti nel programma oggetto.
Per queste ragioni, e per una migliore organizzazione dei programmi, è opportuno inserire le funzioni nel programma C attraverso due fasi distinte tra loro:

• dichiarazione delle funzioni per mezzo dei loro prototipi;
• definizione (o implementazione) delle funzioni.
  

La dichiarazione della funzione, che si intende utilizzare nel programma, di norma va posta in testa al programma, immediatamente dopo la sezione dedicata alle direttive e alla dichiarazione delle variabili globali del programma. Tramite la dichiarazione il programmatore si limita a comunicare al compilatore la sua intenzione di utilizzare una funzione che restituisce un dato di un certo tipo e che utilizza determinati parametri, riservandosi di specificarne il codice in seguito, nella fase di definizione. Questa dichiarazione si chiama prototipo della funzione.
Tutte le funzioni devono essere dichiarate, fatta eccezione per la funzione main che non necessita di dichiarazione, in quanto, essendo la prima funzione ad essere eseguita, non richiede controlli alla chiamata.
La sintassi generale per la dichiarazione di una funzione è:

tipo di dato restituito nome della funzione (elenco dei parametri);

La definizione (o implementazione) della funzione, con le istruzioni che la compongono, viene normalmente posta dopo la funzione main.

ESEMPIO: Scrivere il programma per calcolare l’area e il perimetro di un quadrato fornita da tastiera la misura del lato.

Il programma può essere scomposto in tre parti fondamentali:

• inserimento da tastiera della lunghezza del lato
• calcolo dell’area
• calcolo del perimetro.

A queste tre parti corrispondono tre funzioni che vengono codificate in C nel seguente modo:

int Tastiera(void)
{
int misura;
printf(“Introduci il lato: “);
scanf(“%d”, &misura);
return misura;
}
void CalcoloArea (int l)
{
float area;
area = l * l;
printf(“%10.2f \n”, area);
return;
}
void CalcoloPerimetro (int l)
{
float perim;
perim = l * 4;
printf(“%10.2f \n”, perim);
return;
}

Le variabili misura, area e perim vengono usate solo all’interno delle rispettive funzioni e sono quindi variabili locali.
Il programma completo può quindi essere organizzato in questo modo:

/* Quadrato.c : perimetro e area del quadrato */
#include <stdio.h>
int Tastiera(void);
void CalcoloArea (int l);
void CalcoloPerimetro (int l);

/* funzione principale */
int main(void)
{
int lato;
lato = Tastiera();
CalcoloArea(lato);
CalcoloPerimetro(lato);
return 0;
}

int Tastiera(void)
{
int misura; /* variabile locale */
printf(“Introduci il lato: “);
scanf(“%d”, &misura);
return misura;
}
void CalcoloArea (int l)
{
float area; /* variabile locale */
area = l * l;
printf(“%10.2f \n”, area);
return;
}
void CalcoloPerimetro (int l)
{
float perim; /* variabile locale */
perim = l * 4;
printf(“%10.2f \n”, perim);
return;
}

All’inizio del programma le funzioni vengono soltanto dichiarate, specificandone per ciascuna il tipo restituito, il nome e i parametri richiesti. In questo modo si ottiene una semplice elencazione dei prototipi che facilita la comprensione del programma e realizza in pratica la metodologia top-down.

Se si vuole poi vedere in dettaglio le modalità di elaborazione delle singole funzioni, si può analizzare la definizione delle funzioni scritta dopo la funzione main.
Come abbiamo già visto in precedenza, nelle direttive #include sono specificati i file di intestazione (file con estensione .h) che contengono i prototipi delle funzioni predefinite del linguaggio.
Si osservi che nella dichiarazione dei prototipi delle funzioni, sono indicati per ogni parametro il tipo e il nome, per rendere più comprensibile la lettura del codice. In effetti il linguaggio C consente la dichiarazione delle funzioni con i prototipi indicando solo il tipo, senza il nome, dei parametri.

ESEMPIO: Scrivere un programma per acquisire da tastiera un numero e comunicare all’esterno un messaggio che indichi se il numero è pari o dispari

La funzione Pari riceve come parametro il numero e calcola il resto della divisione per 2. Se il resto è 0, restituisce il valore 1 (Vero), altrimenti ritorna il valore 0 (Falso).

Programma C

/* PariDispari.c : numero pari o dispari */
#include <stdio.h>
int Pari(int x);
/* funzione principale */
int main(void)
{
int y;
printf(“un numero: “);
scanf(“%d”, &y);
if (Pari(y)) printf(“%d numero pari \n”, y);
else printf(“%d numero dispari \n”, y);
return 0;
}
int Pari(int x)
{
int b;
if (x%2 == 0) b = 1;
else b = 0;
return b;
}

La scrittura

if (Pari(y)) …..

significa

if (Pari(y)==1) …..

cioè rappresenta un controllo sul valore logico Vero (=1) della funzione.