Le istruzioni

Costrutto if-else

if (cond) {
  istruzione 1;
  istruzione 2;
  ...
  istruzione n;
}
else {
  istruzione n+1;
  istruzione n+2;
  ...
  istruzione m;
} // else

Il blocco di istruzioni che vanno da istruzione 1 a istruzione n viene eseguito solo se la condizione cond è verificata, in caso contrario vengono eseguite le istruzioni che vanno da istruzione n+1 a istruzione m. Il blocco else è opzionale.

int a=0, b=10;

if (a>b){   // a non è maggiore di b quindi
  b = b+a;  // questo blocco sarà ignorato
}
else {
  a = a+b;  // invece sarà eseguita la somma
} //else

In questo caso vengono confrontate le due variabili a e b (valgono rispettivamente 0 e 10), si può facilmente constatare che la condizione interna all'istruzione if non è verificata; verranno pertanto eseguite le istruzioni interne al blocco else: ad a verrà assegnato il valore 10 ( 0+10 ).

Costrutto switch-case

switch (espressione) {
  case valore1:
    istruzione 1;
    ...
    [break;]
  case valore2:
    istruzione 2;
    ...
    [break;]
  ...
  case valore n:
    istruzione n;
    ...
    [break;]
  default:
    istruzione default;
    ...
    [break;]
} // switch

L'istruzione switch effettua un controllo sul parametro espressione, ne confronta il valore con i valori definiti nei blocchicase ed esegue il blocco corrispondente. Se nessuno dei valori è accettabile, verrà eseguito il blocco default (opzionale).

L'istruzione break permette di uscire dall'intero blocco switch, se omesso dopo aver eseguito il blocco relativo al case saranno eseguiti anche i controlli relativi ai case rimanenti, compreso il default.

int a=10, b=6;

switch (a+b) {
  case 11:
    a = 5;
    break;
  case 15:
    a = 9;
    break;
  default:
    b = 0;
    a = 0;
    break;
} // switch

In questo caso viene confrontato il risultato dell'operazione a+b (16) con i valori specificati nei case, verranno quindi saltati i primi due blocchi di istruzioni (il confronto non dà infatti esito positivo) e sarà eseguito il blocco default: al termine dell'esecuzione dell'istruzione switch le variabili a e b avranno entrambe valore 0.

Costrutto while

while (cond) {
  istruzione 1;
  istruzione 2;
  ...
  istruzione n;
} // while

Il blocco di istruzioni che va da istruzione 1 a istruzione n sarà eseguito ciclicamente finchè la condizione cond resta verificata (ovvero finché restituisce valore true).

int a=0;

while (a < 10) { 
  a = a+1; // questa istruzione viene ripetuta per 10 volte
} // while

In questo caso il ciclo verrà ripetuto 10 volte, ad ogni ripetizione la variabile a sarà incrementata. Raggiunto il valore 10 la condizione a<10 non sarà più verificata e restituirà quindi false, causando l'uscita dal ciclo.

Costrutto for

Sintassi:

for (stato iniziale; condizione di permanenza; incremento) {
  istruzione 1;
  istruzione 2;
  ...
  istruzione n;
} // for

Lo stato iniziale è tipicamente definito da un'espressione di assegnamento. Questa espressione viene eseguita una sola volta all'inizio del ciclo.

La condizione di permanenza viene verificata sempre prima di iniziare ad eseguire le istruzioni del blocco, se tale espressione risulta verificata, viene eseguito il blocco di istruzioni.

l'espressione di incremento viene eseguita alla fine di ogni ripetizione delle istruzioni, prima del controllo sulla condizione.

In modo simile al while il blocco di istruzioni sarà eseguito ciclicamente finchè la condizione di permanenza rimane verificata (valore true), tipicamente tale condizione è relativa alle variabili su cui coinvolte nello stato iniziale e nell'incremento.

int i, a = 10;

for (i = 0; i < 10; i++) {
  a = a - 1;
} // for

Il ciclo sarà ripetuto 10 volte, finchè, cioè, la variabile i (incrementata dall'istruzione i++) non assume valore 10: al fine dell'esecuzione di questa operazione a avrà valore 0.

Costrutto do-while

do {
  istruzione 1;
  istruzione 2;
  ...
  istruzione n;
} while (cond);

La differenza tra un ciclo do-while e un ciclo while sta nel fatto che nel primo la condizione viene controllata dopo aver eseguito le istruzioni interne al blocco, che quindi saranno eseguite almeno una volta.

int a = 9;

do {
  a = 0;
} while (a > 10);

In questo caso il ciclo viene ripetuto una sola volta, con l'effetto di assegnare ad a il valore 0. Nonostante la condizione del ciclo non fosse verificata nemmeno alla prima esecuzione, il blocco viene eseguito comunque almeno una volta.