*
 * Vediamo di prendere confidenza con le funzioni.
 * Riassumiamo intanto il formato:
 *
 *	TipoRitorno NomeFunzione(Lista tipo+nome argomenti in entrata)
 *	{
 *	  corpo della funzione
 *	}
 *
 * Ad esempio:
 *
 *	int somma(int a,int b)	* Funzione che restituisce un valore INT *
 *				* ed ha 2 parametri in entrata sempre INT *
 *	{
 *	   return(a+b);
 *	}
 *
 * Ora vediamo una funzione che non ha parametri in entrata ne' in uscita:
 *
 *	void acapo(void)
 *	{
 *		printf("\n");
 *	}
 *
 * Una che ha solo un parametro in entrata:
 *
 *	void stampanumero(int a)
 *	{
 *		printf("%d",a);
 *	}
 *
 * Ed una che ha solo un parametro in uscita (ossia lo restituisce):
 *
 *	int prendinumero(void)
 *	{
 *		int a;		* Mi serve una variabile locale...*
 *		scanf("%d",&a);
 *		return(a)
 *	}
 *
 * Naturalmente queste funzioni sono cosi' semplici che anziche' aiutare,
 * forse complicano il programma, ma chiariscono come funziona il passaggio
 * di parametri ad una funzione, e l'eventuale ritorno di valori.
 * La cosa da ricordarsi e' che la prima dichiarazione di tipo che facciamo,
 * prima del nome della funzione, si riferisce al valore restituito dalla
 * funzione stessa (con l'instruzione RETURN), per cui abbiamo:
 *
 *	void nomefunzione	-> funzione che non restituisce niente
 *	int nomefunzione	-> funzione che restituisce un valore INT
 *	float nomefunzione	-> funzione che restituisce un valore FLOAT
 *
 * In pratica definiamo il "tipo di ritorno-restituzione".
 * Invece le variabili che mettiamo nella lista degli argomenti, dentro le
 * parentesi (), sono i parametri che saranno passati ALLA funzione, in
 * entrata.
 * Quando la funzione non restituisce alcun valore, si puo' omettere il
 * return, che andrebbe messo senza valori:
 *
 *	{
 *	...
 *	return;		* Si puo' omettere se non si restituisce nulla *
 *	}
 *
 * Si possono mettere anche piu' return, all'interno di una funzione, e fare
 * in modo (tramite if-else o simili) che si esca a causa di un return o
 * di un'altro, per restituire valori diversi o uscire al momento giusto.
 * Altra cosa da notare e' che all'interno di una funzione si possono
 * anche definire delle variabili LOCALI, ossia utilizzabili solo all'interno
 * della funzione, come abbiamo visto in "prendinumero()". Altro esempio:
 *
 *	int somma(int a,int b)	* Funzione che restituisce un valore INT *
 *	{			* ed ha 2 parametri in entrata sempre INT *
 *	   int risultato;	* Definisco una variabile locale *
 *	   risultato=a+b;
 *	   return(risultato);
 *	}
 *
 * Abbiamo un po' complicato la nostra funzione di somma, usando una
 * variabile per il risultato, che pero' non e' indispensabile.
 * Vediamo quindi il listato precedente spezzettato in molte funzioni:
*/

#include <stdio.h>	/* Includiamo la libreria standard */

/* Forniamo una dichiarazione anticipata (prototipo) delle nostre funzioni */

int somma(int,int);		/* Entrata: 2 int,  ritorno: 1 int */
void acapo(void);		/* Entrata: niente, ritorno: niente */
void stampanumero(int);		/* Entrata: 1 int,  ritorno: niente */
int prendinumero(void);		/* Entrata: niente, ritorno: 1 int */

/* Funzione principale e inizio del programma */

int main(void)		/* Funzione principale, eseguita per prima */
{			/* Inizio della funzione main() */

	int pippo,pluto,papero;	/* Definiamo 3 variabili intere */

	acapo();			/* Chiamo acapo() */
	printf("Dammi un numero: ");
	pippo = prendinumero();		/* Chiamo prendinumero() */
	acapo();			/* Chiamo acapo() */
	printf("Dammi un'altro numero: ");
	pluto = prendinumero();		/* Chiamo prendinumero() */
	papero = somma(pippo,pluto);	/* Chiamo somma() */
	acapo();			/* Chiamo acapo() */
	printf("La somma dei due e'");
	acapo();			/* Chiamo acapo() */
	stampanumero(papero);		/* Chiamo stampanumero() */
	return(0);	/* la funzione main restituisce uno 0 intero */
} 			/* Fine della funzione main() */

/* Ora definiamo una funzione chiamata somma(), che in entrata richiede 2
 * variabili di tipo intero, e in uscita restituisce un numero intero, somma
 * dei 2 in entrata.
*/

int somma(int a,int b)
{
	printf("Sto calcolando la somma... com'e' difficile!!!");
	return(a+b);
}

/* Una funzione che non ha parametri in entrata e non restituisce niente */

void acapo(void)
{
	printf("\n");
}

/* Una funzione che ha solo un parametro in entrata */

void stampanumero(int a)
{
	printf("%d",a);
}

/* Una funzione che ha un parametro in uscita (ossia lo restituisce): */

int prendinumero(void)
{
	int a;		/* Mi serve una variabile locale...*/
	scanf("%d",&a);
	return(a);
}

/* Usare le funzioni in un programma cosi' corto e' controproducente, ma
 * piu' il programma diventa grande e piu' le funzioni divengono utili.
 */