LINGUAGGIO C
				Parte 2 (v1.0)
				
				Il ciclo while


Nella prima parte abbiamo parlato delle primissime cose da scrivere per iniziare un banale programma C e abbiamo scritto e analizzato il codice necessario per un piccolo algoritmo di somma.

In questa lezione miglioreremo il nostro programmino, inserendo il concetto di "ciclo".

L'utente, nel nostro programma, deve lanciare una esecuzione ogni qualvolta desideri fare un'addizione, e ciò è scomodo.
Vogliamo che l'utente possa fare tutte le somme che desidera, e terminare il programma quando non ha più nulla da sommare, proprio come si spegnerebbe una calcolatrice.
Per fare questo abbiamo bisogno di un "ciclo".

In C esistono almeno due modi per fare un ciclo, il for e il while.
Sebbene siano per molti aspetti equivalenti, qui vedremo il while (in italiano "mentre"), perchè tra i due è quello che meglio si avvicina all'intuizione di "fare qualcosa finchè voglio io".

Di seguito riporto il codice della nostra calcolatrice, che chiameremo calcol.c, con l'aggiunta del while.

#include <stdio.h>

main(){
	int a, b, somma;			// dichiarazione variabili
	int cont=1;
	
	while(cont){
		printf("Inserire primo numero: ");
		scanf("%d", &a);
		printf("Inserire secondo numero: ");
		scanf("%d", &b);
	
		somma = a+b;				

		printf("La somma è: %d\n", somma);
		printf("Premere 0 per terminare, 1 per continuare ");
		scanf("%d", &cont);
	};

printf("Fine programma");
}


Abbiamo dovuto aggiungere almeno due nuovi componenti.
Uno è chiaramente il while, che come si può notare apre un nuovo corpo all'interno del corpo del main (notare le parentesi graffe e l'indentazione).
L'altro è la variabile cont, anch'essa di tipo intero.
A cosa serve cont?
Un passo per volta.
Passiamo alla spiegazione della sintassi del while.
Inizia chiaramente con la keyword "while", seguita da un'espressione tra parentesi tonde. L'espressione si chiama "guardia", ed è proprio una guardia, in quanto controlla fino a quando mantenere attivo il ciclo.
Qui subentra il concetto di aritmetica booleana, quella dei vero/falso.
L'espressione guardia del while viene calcolata in modo da restituire un risultato booleano, quindi due soli risultati sono ammissibili: vero o falso.
L'intuizione è che il ciclo continua a "ciclare" finchè la guardia è vera, smette appena diventa falsa. La guardia viene ricalcolata all'inizio di ogni ciclo.
Ora, nel C il tipo di dato booleano non esiste, pertanto il falso è rappresentato dal numero zero, mentre il vero è qualunque altro numero.
La variabile cont è presettata a 1 in fase di inizializzazione, pertanto al primo ciclo si può leggere "while(1)", che è come dire "while(vero)", quindi entra nel ciclo.
A risultato ottenuto il sistema chiede all'utente se continuare o meno, indicando la pressione del tasto zero per terminare.
In realtà il numero preso in input dalla scanf viene assegnato a cont, poi termina il ciclo (chiamato anche iterazione). Quindi si ripassa al controllo della guardia. Se nell'ultima operazione l'utente ha premuto 0, il sistema salterà tutto il corpo del ciclo per andare alla printf successiva, altrimenti tutto ricomincerà.

Facciamo ora un esempio di esecuzione in cui l'utente vorrà eseguire due somme prima di andarsene.

Inserire il primo numero: 67
Inserire il secondo numero: 9
La somma e': 76
Premere 0 per terminare, 1 per continuare 1
Inserire il primo numero: 8
Inserire il secondo numero: 108
La somma e': 116
Premere 0 per terminare, 1 per continuare 0
Fine programma


NB: attenzione! Il ciclo while, come tutti i cicli, rischia di causare il cosidetto loop, una tipologia di errore che non fa mai terminare il programma.
Provate a pensare alla nostra calcolatrice senza l'ultima scanf... cont non verrebbe mai modificata e risulterebbe sempre 1, causando...
Proprio così. E questo è uno degli errori di dimenticanza che di solito più si pagano!

ALTRE INFO SULLE GUARDIE
Le guardie del while abbiamo detto essere espressioni. Già, ma nel nostro programmino non c'è una espressione, c'è un semplice nome di variabile.
Questo perchè il C permette queste cose. In pratica è come se ci fosse scritto "cont!=0", che significa "mentre cont è diversa da 0, quindi vera, fai..."
Le espressioni classiche, comunque, si basano su alcuni operatori come l'uguaglianza, il diverso da, l'and e l'or, tutti gli operatori classici dell'aritmetica booleana, insomma.
Di seguito la codifica dei principali operatori booleani per il C:

uguaglianza		==
disugaglianza		!=
and 			&&
or			||
not			!
maggiore di		>
minore di		<
maggiore o uguale	>=
minore o uguale		<=

e qualche esempio:

"a uguale a b"		a==b		NB: notare che non è a=b!!! che causerebbe l'assegnamento ad 					a del valore di b!
"a diverso da c"	a!=c
"a and b"		a && b
"a or b"		a || b
"non a"			!a
a maggiore di b		a>b
a minore o uguale a b	a<=b

Capiremo meglio queste terminologie quando, nella prossima parte, parleremo del costrutto if...else e dei condizionali.

Possibili esercizi:
1) modificare calcol.c in modo che il programma termini quando l'ultima somma effettuata abbia dato come risultato un numero maggiore di 100.

2) modificare il programma in modo che termini dopo 5 iterazioni, senza dar modo all'utente di scegliere.


/********************************************************************************
Tutte le informazioni contenute in questo file non sono state prese da alcun    *
manuale o libro presente sul mercato e non si è quindi violato alcun copyright. *
Questo è il frutto della mia esperienza e dei miei studi ufficiali e privati.   *
*********************************************************************************/