Istruzioni Semplici e Composte in C++

Istruzioni Semplici

La maggior parte delle istruzioni in C++ termina con un punto e virgola.

Un'espressione, come ival + 5, diventa un'istruzione espressione quando è seguita da un punto e virgola. Le istruzioni espressione causano la valutazione dell'espressione e il suo risultato viene scartato:

// istruzione espressione piuttosto inutile
ival + 5;

// istruzione espressione utile
cout << ival;

La prima istruzione è piuttosto inutile: L'addizione viene eseguita ma il risultato non viene usato. Più comunemente, un'istruzione espressione contiene un'espressione che ha un effetto collaterale quando viene valutata, come assegnare un nuovo valore a una variabile, o stampare un risultato.

Istruzioni Nulle

L'istruzione più semplice è l'istruzione vuota, nota anche come istruzione nulla. Un'istruzione nulla è un singolo punto e virgola:

; // istruzione nulla

Un'istruzione nulla è utile dove il linguaggio richiede un'istruzione ma la logica del programma non lo fa. Tale utilizzo è più comune quando il lavoro di un ciclo può essere fatto all'interno della sua condizione. Ad esempio, potremmo voler leggere uno stream di input, ignorando tutto ciò che leggiamo finché non incontriamo un particolare valore:

// leggi finché non raggiungiamo la fine del file
// o troviamo un input uguale a cercato
while (cin >> s && s != cercato)
    ; // istruzione nulla

Questa condizione legge un valore dallo standard input e testa implicitamente cin per vedere se la lettura ha avuto successo. Assumendo che la lettura sia riuscita, la seconda parte della condizione testa se il valore che abbiamo letto è uguale al valore in cercato. Se abbiamo trovato il valore che vogliamo, il ciclo while viene terminato. Altrimenti, la condizione viene valutata di nuovo, il che legge un altro valore da cin.

Le istruzioni nulle dovrebbero essere commentate. In questo modo chiunque legga il codice può vedere che l'istruzione è stata omessa intenzionalmente.

Attenzione ai Punti e Virgola Mancanti o Superflui

Poiché un'istruzione nulla è un'istruzione, essa è legale ovunque sia prevista un'istruzione.

Per questa ragione, i punti e virgola che potrebbero apparire illegali sono spesso nient'altro che istruzioni nulle. Il seguente frammento contiene due istruzioni, ossia un'istruzione espressione e un'istruzione nulla:

// OK: il secondo punto e virgola è un'istruzione nulla superflua
ival = v1 + v2;;

Sebbene un'istruzione nulla non necessaria sia spesso innocua, un punto e virgola extra che segue la condizione in un while o if può alterare drasticamente l'intento del programmatore. Ad esempio, il seguente codice eseguirà un ciclo infinito:

// DISASTRO: punto e virgola extra:
// il corpo del ciclo è questa istruzione nulla
while (iter != svec.end()) ; // il corpo del while è l'istruzione vuota
     ++iter; // l'incremento non fa parte del ciclo

Contrariamente all'indentazione, l'incremento non fa parte del ciclo. Il corpo del ciclo è l'istruzione nulla formata dal punto e virgola che segue la condizione.

Le istruzioni nulle superflue non sono sempre innocue.

Istruzioni Composte o Blocchi

Un'istruzione composta, solitamente chiamata blocco, è una sequenza (anche vuota) di istruzioni e dichiarazioni circondata da una coppia di parentesi graffe.

Un blocco è un ambito o scope a se stante. I nomi introdotti all'interno di un blocco sono accessibili solo in quel blocco e nei blocchi annidati all'interno di quel blocco. I nomi sono visibili da dove vengono definiti fino alla fine del blocco che li racchiude (immediatamente).

Le istruzioni composte sono usate quando il linguaggio richiede una singola istruzione ma la logica del nostro programma necessita di più di una. Ad esempio, il corpo di un ciclo while o for deve essere una singola istruzione, eppure spesso abbiamo bisogno di eseguire più di un'istruzione nel corpo di un ciclo. Lo facciamo racchiudendo le istruzioni in parentesi graffe, trasformando così la sequenza di istruzioni in un blocco.

Come esempio, analizziamo il ciclo while di questo esempio in cui sommiamo i primi 10 numeri interi:

#include <iostream>

int main() {
    int somma = 0;
    int val = 1;

    while (val <= 10) {
        somma += val; // assegna somma + val a somma
        ++val; // aggiungi 1 a val
    }

    std::cout << "La somma dei primi 10 numeri interi è: " << somma << std::endl;

    return 0;
}

La logica del nostro programma necessita di due istruzioni nel ciclo: aggiornare somma e incrementare val.

Tuttavia, un ciclo while può contenere solo un'istruzione. Racchiudendo queste istruzioni in parentesi graffe, le abbiamo trasformate in una singola istruzione (composta).

Un blocco non è terminato da un punto e virgola.

Possiamo anche definire un blocco vuoto scrivendo una coppia di graffe senza istruzioni. Un blocco vuoto è equivalente a un'istruzione nulla:

while (cin >> s && s != cercato)
    { } // blocco vuoto