In programmazione per "condizione" si intende solitamente quel processo che vede l'esecuzione di una verifica di una determinata espressione (es. "la casa è bianca?") e, in base alla sua veridicità/falsità, si portano avanti azioni diverse. Vediamo subito un esempio puramente teorico:

//ESEMPIO TEORICO DI CONDIZIONE

//Stabiliamo subito (arbitrariamente) che
//la casa A è bianca ----------------------------> IMPOSTIAMO LA VARIABILE CHE ENTRERA' IN GIOCO

//Ecco quindi la nostra condizione:

//SE la casa è bianca allora --------------------> CONDIZIONE 1 DA VERIFICARE
//dipingila di rosso. ---------------------------> AZIONE DA ESEGUIRE SE LA CONDIZIONE E' VERIFICATA

//SE INVECE la casa è gialla allora -------------> CONDIZIONE 2 VERIFICABILE SOLO SE LA CONDIZIONE 1 E' FALSA
//dipingila di blu. -----------------------------> AZIONE DA ESEGUIRE SE LA CONDIZIONE 2 E' VERIFICATA

//SE invece è di un QUALSIASI ALTRO colore ------> CONDIZIONE ALTERNATIVA
//dipingila di verde. ---------------------------> AZIONE DA ESEGUIRE SE LE CONDIZIONI 1 E 2 SONO FALSE

Come si può facilmente notare non c'è nulla di difficile in questo esempio, passiamo quindi ad una rappresentazione più rigorosa.

LE ISTRUZIONI IF, ELSE E IF ELSE
In assoluto le istruzioni che verranno più utilizzate

int casa = 1;

if (casa == 1) {
casa = 2;
}

else if (casa == 3) {
casa = 4;
}

else {
casa = 5;
}

Per prima cosa possiamo dire che "if" (la nostra prima istruzione condizionale) corrisponde alla dicitura italiana "se" (es. "se la casa è bianca..."), "else if" alla dizione "invece se" e "else" potrebbe corrispondere alla dizione "in tutti gli altri casi" ma per essere più chiari applichiamo il caso teorico al caso pratico:

//la casa A è bianca ----------------------------> IMPOSTIAMO LA VARIABILE CHE ENTRERA' IN GIOCO
int casa = 1;

//Ecco quindi la nostra condizione:

//SE la casa è bianca allora --------------------> CONDIZIONE 1 DA VERIFICARE
if (casa == 1) {
//dipingila di rosso. ---------------------------> AZIONE DA ESEGUIRE SE LA CONDIZIONE E' VERIFICATA
casa = 2;
}

//SE INVECE la casa è gialla allora -------------> CONDIZIONE 2 VERIFICABILE SOLO SE LA CONDIZIONE 1 E' FALSA
else if (casa == 3) {
//dipingila di blu. -----------------------------> AZIONE DA ESEGUIRE SE LA CONDIZIONE 2 E' VERIFICATA
casa = 4;
}

//SE INVECE è di un qualsiasi altro colore ------> CONDIZIONE ALTERNATIVA
else {
//dipingila di verde. ---------------------------> AZIONE DA ESEGUIRE SE LE CONDIZIONI 1 E 2 SONO FALSE
casa = 5;
}

• Le parentesi tonde "()" delimitano, come è facile intuire, la condizione da verificare.
• All'interno delle condizioni è possibile inserire tutti gli operatori del C++ (es. "if (casa != 1 && casa >= 2 || casa < 100)").
• "else" non ha una condizione specificabile dato che sottintende "in tutti gli altri casi...".
• Le parentesi graffe "{}" delimitano l'azione da svolgere al verificarsi delle condizioni, tuttavia, se l'azione è di una sola riga di codice è possibile ometterle (questa pratica, per una questione di chiarezza, è sconsigliata).
• L'unica istruzione che deve essere specificata è "if"; "else" ed "else if" sono facoltativi.
• In una condizione ci possono essere: solo un "if", infiniti "else if" e solo un "else" (è importante inoltre metterli sempre in questo ordine).
• Soltanto una condizione può essere eseguita (es. se "if" è falso il programma passa a verificare automaticamente, se specificati, gli "else if" e per ultimo, se esiste, il caso "else").
• E' sempre possibile mettere un'istruzione "if" all'interno di un'altra purchè l'una includa l'altra comprendendo condizioni, azioni e parentesi (in questo caso si parla di istruzioni "nidificate"); se non strettamente necessario, almeno agli inizi, è meglio cercare di non "nidificare" troppo.

L'ISTRUZIONE CONDIZIONALE ?
Un accenno al suo funzionamento e utilità

Compreso il funzionamento di "if" sarà adesso davvero intuitiva la comprensione dell'istruzione condizionale ? (di cui avevamo già fatto menzione nella lezione a riguardo degli operatori). Diamo subito una rapida occhiata al seguente esempio:

// parteDaVerificare ? azioneSeRisultaVerificata : azioneSeRisultaFalsa;

// Proviamo a riportare l'esempio precedente:
int casa = 1;
(casa==1) ? casa = 2 : casa = 3;

L'istruzione condizionale ? (chiamata anche operatore ternario) restituisce "rapidamente" un valore true o false (vero o falso) e in base a quest'ultimo esegue rispettivamente o la prima azione o la seconda. In particolare il listato appena preso in considerazione restituisce "casa" uguale a 2 (la casa bianca viene dipinta di rosso).

L'ISTRUZIONE SWITCH
Analizzare molti casi

// ESEMPIO TEORICO DI SWITCH:

//STABILIAMO CHE ABITAZIONE E' UGUALE A 1


// SE L'ABITAZIONE E'

// UGUALE A 1 ALLORA
//DIPINGILA DI ROSSO
//ED ESCI DALL'ISTRUZIONE

// UGUALE A 2 ALLORA
//DIPINGILA DI MARRONE
//ED ESCI DALL'ISTRUZIONE

// UGUALE A 3 ALLORA
//DIPINGILA DI FUCSIA
//ED ESCI DALL'ISTRUZIONE

// IN TUTTI GLI ALTRI CASI
//DIPINGILA DI NERO

Gli "switch" sono dei validi sostituti di sequenze di "if" o di "if" con troppi "else if". gli "switch" funzionano difatti in maniera piuttosto simile ai loro "compagni" ma permettono, di fronte ad esempio ad una lunga lista di possibili valori che può assumere la condizione da verificare, un codice meno macchinoso e più efficace. L'unica vera differenza sta nel fatto che per uscire dall'istruzione e far si che non vengano più eseguiti i successivi casi è necessario interrompere l'esecuzione dello "switch" (con il comando "break"). Ma vediamone una sintassi rigorosa commentata:

// DICHIARIAMO LA NOSTRA VARIABILE
int abitazione = 1;


// SE L'ABITAZIONE E'
switch (abitazione)
{

// UGUALE A 1 ALLORA
case(1):
//DIPINGILA DI ROSSO
abitazione = 2;
break;

// UGUALE A 2 ALLORA
case(2):
//DIPINGILA DI MARRONE
abitazione = 7;
break;

// UGUALE A 3 ALLORA
case(3):
//DIPINGILA DI FUCSIA
abitazione = 8;
break;

// IN TUTTI GLI ALTRI CASI
default:
//DIPINGILA DI NERO
abitazione = 9;

}

Scendiamo più nel dettaglio nelle varie parti:

• "switch (abitazione) {" rappresenta l'inizio della nostra istruzione; si potrebbe dire che "abitazione" sia ciò che deve essere analizzato dai vari casi.
• "case(1):" sta ad indicare il caso in cui "abitazione" sia uguale a 1.
• "abitazione = 2;" è l'azione che viene svolta nel caso in cui "abitazione" sia uguale a 1.
• "break;" serve a far si che non vengano eseguiti i "case" successivi e permette al flusso del programma di procedere dalla chiusa parentesi graffa "}" in poi (se "break" viene omesso verranno eseguiti senza essere verificati tutti i casi a lui successivi).
• "default:" si tratterebbe di una specie di "else", esso contempla infatti tutti i "case" non specificati (una specie di "case else").
• "}" chiude l'istruzione "switch".

Ancora una serie di notazioni generali a riguardo di "switch":

• Il numero di "case" può essere infinito.
• In tutta l'istruzione, all'interno delle parentesi tonde "()" possono essere inserite espressioni complesse di varia natura;
• Di "default" ce ne può essere uno solo (come per il suo corrispettivo "else") e dopo di lui non deve esserci alcun "break" ma solo la chiusura della graffa "}".
• Omettere il "break" non è un errore ma un modo per far si che tutti i "case" successivi vengano eseguiti senza essere verificati.
• E' possibile "nidificare" (come per "if"), all'interno di un "case", altri "switch".

RIASSUNTO DELLA LEZIONE, ESEMPI E CHIARIMENTI
Quando usare una determinata struttura piuttosto che un'altra

Ciascuna delle strutture trattate in questa lezione può essere usata liberamente per fare svariate operazioni anche se talvolta una di esse può risultare più efficace di un'altra. Ecco di seguito le istruzione che abbiamo imparato affiancate da una breve descrizione sul "quando usarle" (non si tratta di regole fisse):

• "?:" è utile per fare rapidi test o verifiche.
• "if" serve in casi in cui vi siano da verificare espressioni più complesse, articolare ma non in numero superiore a tre.
• "switch" permette una più amplia ma forse "meno gestibile" analisi di una condizione: ottimo nei casi lunghi e ripetitivi.
• "if" e "switch" possono (volendo) rispettivamente "nidificarsi" l'un l'altro mentre "?:" può solo essere incluso e non può includere.

Concludiamo la lezione con un esempio chiarificatore delle istruzioni appena apprese:

int casa = 3;

//Usiamo IF
if (casa > 1 || casa == 0) {
casa = 2;
}

//Usiamo ?:
(casa > 1) ? casa = 12 : casa = 0;

//Usiamo SWITCH
switch (casa) {
case(1):
casa = 2;
break;

case(3):
casa = 7;
break;

case(6):
casa = 8;
break;

default:
casa = 100;
}