Prendere decisioni

Da una lista a un bivio

Finora i nostri programmi erano una lista: il computer eseguiva le istruzioni dall’alto in basso, tutte, sempre. Utile, ma rigido. Un programma vero deve poter dire “se succede questo, fai quello”. È il primo passo per farlo pensare.

Lo strumento è l’istruzione if (“se”), e ricordi il tipo bool del modulo 1? Eccolo al lavoro:

import std::io;

fn void main()
{
	int temperature = 17;

	if (temperature < 19)
	{
		io::printn("Turning the heating on.");
	}
	io::printn("Done.");
}

Turning the heating on.
Done.

Leggila così: ”se la temperatura è minore di 19, esegui quello che c’è tra le graffe”. La condizione tra parentesi, temperature < 19, è un confronto: produce un bool, cioè true o false. Se è true il blocco viene eseguito; se è false viene saltato e il programma riprende subito dopo la graffa chiusa.

Prova a cambiare 17 in 22: il programma stampa solo Done..

Altrimenti: else

Spesso vuoi fare una cosa oppure un’altra. Per il ramo “altrimenti” c’è else:

int age = 15;

if (age >= 18)
{
	io::printn("You can vote.");
}
else
{
	io::printn("Not yet: wait a few years.");
}

Not yet: wait a few years.

Esattamente uno dei due blocchi viene eseguito, mai entrambi, mai nessuno.

Più strade: else if

E quando le strade sono più di due? Si mettono in fila con else if:

import std::io;

fn void main()
{
	int score = 72;

	if (score >= 90)
	{
		io::printn("Excellent");
	}
	else if (score >= 70)
	{
		io::printn("Good");
	}
	else if (score >= 50)
	{
		io::printn("Sufficient");
	}
	else
	{
		io::printn("Insufficient");
	}
}

Good

Le condizioni vengono controllate dall’alto in basso, e vince la prima vera: le altre non vengono nemmeno guardate. Con 72, score >= 90 è falsa, score >= 70 è vera: stampa Good e ha finito. Anche se score >= 50 sarebbe vera pure lei, non ci arriva mai. L’else finale raccoglie tutto quello che non è stato preso prima.

Le graffe: quando C3 le pretende

Se il blocco contiene una sola istruzione, puoi scrivere l’if tutto su una riga, senza graffe:

if (n < 0) n = -n;   // if n is negative, make it positive

Ma C3 mette due paletti, e il compilatore li fa rispettare:

1. L’istruzione deve stare sulla stessa riga dell’if. Se vai a capo senza graffe, l’errore è: The 'then' part of a single line if-statement must start on the same line as the 'if' or use '{ }'.
2. Se c’è un else, le graffe sono obbligatorie, anche per una sola istruzione: if-statements with an 'else' must use '{ }' even around a single statement.

Condizioni composte

Nel modulo 1 abbiamo visto &&, || e !. Dentro un if danno il meglio:

int hour = 14;
bool is_weekend = false;

if (hour >= 9 && hour < 18 && !is_weekend)
{
	io::printn("The shop is open.");
}

The shop is open.

“Se sono le 9 o più, e prima delle 18, e non è weekend.” Ricorda il cortocircuito: appena una condizione di un && è falsa, le successive non vengono valutate.

Le variabili vivono nel loro blocco

Una variabile dichiarata dentro le graffe esiste solo lì dentro. Quando il blocco finisce, sparisce:

int price = 120;
if (price > 100)
{
	int discount = 20;
	price -= discount;
}
io::printn(price);
io::printn(discount);   // error!

La prima stampa va benissimo (price è dichiarata fuori), la seconda no: fuori dal blocco discount non esiste più, e il compilatore risponde “‘discount’ could not be found, did you spell it right?”. Questa “zona di vita” di una variabile si chiama scope (visibilità).

E c’è una regola in più, tutta di C3: dentro un blocco non puoi dichiarare una variabile con lo stesso nome di una già visibile fuori.

int x = 1;
{
	int x = 2;   // error: 'x' would shadow a previous declaration.
}

In molti linguaggi è permesso (si chiama shadowing, “mettere in ombra”) ed è una fonte classica di confusione: due x diverse a poche righe di distanza. C3 lo vieta, così x è sempre e solo una.

L’operatore ternario

Capita spesso di voler scegliere tra due valori, non tra due blocchi di codice. Per questo esiste l’operatore ternario condizione ? se_vero : se_falso:

int n = 7;
String parity = n % 2 == 0 ? "even" : "odd";
io::printn(parity);

int count = 1;
io::printfn("%d %s", count, count == 1 ? "item" : "items");

odd
1 item

Si chiama “ternario” perché ha tre pezzi. È un’espressione: produce un valore, quindi puoi metterlo dove metteresti un valore, come dentro una printfn. Il secondo esempio risolve un problema eterno: “1 items” è brutto, e così il plurale si sistema da solo.

import std::io;

fn void main()
{
	int temperature = 23;
	int humidity = 70;

	if (temperature < 18)
	{
		io::printn("Cold");
	}
	else if (temperature <= 24)
	{
		io::printn("Comfortable");
	}
	else
	{
		io::printn("Hot");
	}

	io::printn(humidity > 60 ? "Humid" : "Dry");

	if (temperature > 20 && humidity > 60) io::printn("Muggy day");
}

Ricapitolando

• if (condizione) { ... } esegue il blocco solo se la condizione è vera.
• else è il ramo “altrimenti”; else if mette in fila più alternative, e vince la prima vera.
• Senza graffe, l’istruzione deve stare sulla stessa riga dell’if; con un else le graffe sono obbligatorie.
• Una variabile dichiarata in un blocco vive solo lì (scope), e non può avere lo stesso nome di una già visibile.
• c ? a : b sceglie tra due valori; a ?: b dà un valore di riserva.

Una catena di else if che confronta la stessa variabile con tanti valori diventa presto lunga. Per quel caso C3 ha uno strumento su misura: switch.