Operatori ed espressioni in C++

Un'espressione è una combinazione di valori, variabili e operatori che, una volta valutata, produce un risultato. Gli operatori sono i simboli che indicano quali operazioni eseguire sui dati. Il C++ offre un insieme molto ricco di operatori, suddivisi in categorie a seconda del tipo di operazione che descrivono: aritmetici, relazionali, logici, di assegnamento e bit a bit. Padroneggiarli è indispensabile per scrivere qualsiasi logica di calcolo.

Operatori aritmetici

Gli operatori aritmetici eseguono le operazioni matematiche di base. Oltre a somma, sottrazione, moltiplicazione e divisione, è presente l'operatore modulo, che restituisce il resto della divisione intera ed è utilissimo per verificare divisibilità o per far ciclare valori entro un intervallo.

#include <iostream>

int main() {
    int a = 17;
    int b = 5;

    std::cout << a + b << std::endl;   // Somma: 22
    std::cout << a - b << std::endl;   // Differenza: 12
    std::cout << a * b << std::endl;   // Prodotto: 85
    std::cout << a / b << std::endl;   // Divisione intera: 3
    std::cout << a % b << std::endl;   // Resto: 2
    return 0;
}

Va prestata attenzione alla divisione: quando entrambi gli operandi sono interi, il risultato è intero e la parte decimale viene scartata. Per ottenere un risultato in virgola mobile è necessario che almeno uno dei due operandi sia di tipo double o float.

Operatori relazionali

Gli operatori relazionali confrontano due valori e restituiscono sempre un risultato booleano, cioè true oppure false. Sono il fondamento delle decisioni nei programmi, perché permettono di esprimere condizioni da verificare.

int x = 8;
int y = 12;

bool equal = (x == y);          // Uguaglianza: false
bool different = (x != y);      // Disuguaglianza: true
bool less = (x < y);            // Minore: true
bool greaterOrEqual = (x >= y); // Maggiore o uguale: false

È importante non confondere l'operatore di uguaglianza == con l'operatore di assegnamento =. Il primo confronta due valori, il secondo assegna un valore a una variabile: questa è una delle fonti di errore più comuni per chi inizia.

Operatori logici

Gli operatori logici combinano espressioni booleane. L'operatore && rappresenta la congiunzione (vero solo se entrambe le condizioni sono vere), || rappresenta la disgiunzione (vero se almeno una è vera) e ! rappresenta la negazione. Questi operatori adottano la valutazione a corto circuito: la seconda condizione viene valutata solo se necessario, il che permette anche di evitare operazioni potenzialmente rischiose.

int userAge = 25;
bool hasLicense = true;

bool canDrive = (userAge >= 18) && hasLicense;   // Vero solo se entrambe vere
bool needsCheck = (userAge < 18) || !hasLicense;  // Vero se almeno una vera

Operatori di assegnamento composti

Gli operatori di assegnamento composti permettono di aggiornare il valore di una variabile combinando un'operazione e un assegnamento in un'unica forma più concisa. Sono semplici scorciatoie: total += 5 equivale esattamente a total = total + 5.

int balance = 100;

balance += 50;   // Ora vale 150
balance -= 30;   // Ora vale 120
balance *= 2;    // Ora vale 240
balance /= 4;    // Ora vale 60

Incremento e decremento

Gli operatori di incremento ++ e decremento -- aumentano o diminuiscono di una unità il valore di una variabile. Esistono nella forma prefissa e postfissa: nella forma prefissa la variabile viene modificata prima di essere usata nell'espressione, in quella postfissa viene usata e poi modificata. La differenza diventa rilevante solo quando l'operatore è inserito all'interno di un'espressione più ampia.

int counter = 5;

int first = ++counter;   // counter diventa 6, poi first riceve 6
int second = counter++;  // second riceve 6, poi counter diventa 7

Precedenza e parentesi

Quando in un'espressione compaiono più operatori, l'ordine in cui vengono valutati è regolato dalle regole di precedenza, simili a quelle dell'aritmetica: la moltiplicazione viene prima dell'addizione, e così via. Per evitare ambiguità e rendere il codice più leggibile, è sempre consigliabile usare le parentesi tonde per esprimere chiaramente l'ordine desiderato, anche quando le regole di precedenza renderebbero superfluo l'intervento.

int value = 2 + 3 * 4;        // Vale 14: la moltiplicazione ha precedenza
int clarified = (2 + 3) * 4;  // Vale 20: le parentesi cambiano l'ordine

Comprendere bene operatori ed espressioni è il presupposto per costruire la logica dei programmi. Nel prossimo articolo vedremo come usare le espressioni booleane all'interno delle strutture di controllo, per far prendere decisioni e ripetere operazioni al nostro codice.