Operatori in C++: aritmetici, di confronto, logici e altri

Cosa fanno gli operatori

Un operatore è un simbolo che esegue un'azione su uno o più valori, chiamati operandi. Ne hai già usato uno: il = che lega un valore a una variabile. C++ offre un ricco insieme di operatori per matematica, confronti, logica e manipolazione di bit, e qualche spigolo vivo che mette in difficoltà chi inizia.

Nella pagina precedente hai visto come const blocca un valore. Gli operatori sono il modo in cui calcoli i valori che memorizzi, costanti o no. Vediamo le famiglie che userai ogni giorno.

Operatori aritmetici

I cinque operatori aritmetici sono +, -, *, / e % (modulo, il resto di una divisione):

#include <iostream>
using namespace std;

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

    cout << "sum:       " << a + b << "\n";
    cout << "difference: " << a - b << "\n";
    cout << "product:    " << a * b << "\n";
    cout << "quotient:   " << a / b << "\n";
    cout << "remainder:  " << a % b << "\n";

    return 0;
}

La grande trappola si nasconde in quel quoziente. 17 / 5 stampa 3, non 3.4. Quando entrambi gli operandi sono interi, / esegue la divisione intera e butta via la parte frazionaria: tronca verso lo zero, non arrotonda. Se vuoi una vera frazione, almeno un operando deve essere in virgola mobile:

#include <iostream>
using namespace std;

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

    cout << a / b << "\n";          // 3  -> divisione intera
    cout << 17.0 / 5 << "\n";       // 3.4 -> 17.0 è un double
    cout << (double)a / b << "\n";  // 3.4 -> prima converti un operando

    return 0;
}

L'operatore % funziona solo con gli interi. Usare % su un double è un errore di compilazione: per il resto in virgola mobile usa std::fmod da <cmath>.

Assegnazione e operatori composti

Un singolo = assegna, non confronta. C++ ti offre forme composte che uniscono un'operazione e un'assegnazione, così non ripeti il nome della variabile:

#include <iostream>
using namespace std;

int main() {
    int score = 10;

    score += 5;   // score = score + 5  -> 15
    score -= 3;   // 12
    score *= 2;   // 24
    score /= 4;   // 6
    score %= 4;   // 2

    cout << score << "\n";   // 2
    return 0;
}

Un errore classico e doloroso è scrivere = dove intendevi == dentro una condizione. if (x = 0) assegna 0 a x e poi valuta il risultato (che è falso), invece di confrontare. I compilatori moderni lo segnalano con un avviso quando attivi gli avvisi: tieni attivo -Wall e prendi sul serio l'avviso.

Operatori di confronto

Gli operatori di confronto pongono una domanda sì/no e producono un bool (true o false):

#include <iostream>
using namespace std;

int main() {
    int x = 7, y = 10;

    cout << (x == y) << "\n";  // 0  (false)
    cout << (x != y) << "\n";  // 1  (true)
    cout << (x <  y) << "\n";  // 1
    cout << (x >= 7) << "\n";  // 1

    cout << boolalpha;          // stampa true/false invece di 1/0
    cout << (x < y) << "\n";    // true
    return 0;
}

Per default cout stampa un bool come 1 o 0. Invia boolalpha allo stream una volta e passa alle parole true/false per il resto di quello stream.

Una trappola sottile: non concatenare confronti come 1 < x < 10. Viene interpretato come (1 < x) < 10: il primo confronto produce un bool (0 o 1), che viene poi confrontato con 10, quindi il tutto è quasi sempre true. Scrivi invece 1 < x && x < 10.

Operatori logici e cortocircuito

&& (e), || (o) e ! (non) combinano espressioni booleane. I primi due sono a cortocircuito: la valutazione si ferma non appena il risultato è noto.

#include <iostream>
using namespace std;

bool check(const char* label) {
    cout << "checked " << label << "\n";
    return true;
}

int main() {
    // Il lato destro di && viene saltato perché il sinistro è false:
    if (false && check("A")) {}

    // Il lato destro di || viene saltato perché il sinistro è true:
    if (true || check("B")) {}

    cout << "done\n";
    return 0;
}

Né check("A") né check("B") vengono mai eseguiti: questo è il cortocircuito. Non è solo un'ottimizzazione, è uno strumento. Puoi scrivere in sicurezza if (ptr != nullptr && ptr->ready) perché la parte ptr->ready viene raggiunta solo quando ptr non è nullo, evitando di dereferenziare un puntatore non valido.

Incremento e decremento

++ aggiunge uno; -- sottrae uno. Ognuno ha una forma prefissa e una postfissa, e la differenza conta quando usi il risultato:

#include <iostream>
using namespace std;

int main() {
    int i = 5;
    cout << ++i << "\n";  // incrementa a 6, poi stampa 6 (pre)

    int j = 5;
    cout << j++ << "\n";  // stampa 5, POI incrementa a 6 (post)
    cout << j   << "\n";  // 6

    return 0;
}

Quando vuoi solo l'effetto collaterale (per esempio in un ciclo for), preferisci ++i. Per un semplice int è identico, ma per tipi più pesanti come gli iteratori il post-incremento deve prima copiare il vecchio valore, ed è lavoro sprecato.

Un altro avvertimento: non modificare la stessa variabile due volte in una sola espressione, come i = i++ + 1; o arr[i] = i++;. L'ordine di quegli aggiornamenti non è specificato e il risultato è undefined behavior. Limita ogni variabile a una sola modifica per istruzione.

Operatori bit a bit e precedenza

Per il lavoro a basso livello ci sono gli operatori bit a bit: & (and), | (or), ^ (xor), ~ (not) e gli shift << e >>.

#include <iostream>
using namespace std;

int main() {
    unsigned int flags = 0b0101;   // letterale binario: 5

    cout << (flags & 0b0001) << "\n";  // 1  -> il bit 0 è attivo
    cout << (flags | 0b0010) << "\n";  // 7  -> attiva il bit 1
    cout << (flags ^ 0b0101) << "\n";  // 0  -> xor con se stesso
    cout << (flags << 1)      << "\n"; // 10 -> shift a sinistra, lo raddoppia

    return 0;
}

Attenzione: << e >> sono anche gli operatori di stream di cout. Dentro una riga con cout di solito servono le parentesi attorno a uno shift di bit, altrimenti il compilatore lo legge come un inserimento nello stream.

Infine, la precedenza decide cosa si lega per primo quando mescoli gli operatori. * e / legano più forte di + e -, proprio come in matematica, quindi 2 + 3 * 4 vale 14. Il confronto lega meno dell'aritmetica, e i logici &&/|| ancora meno. Nel dubbio, non imparare a memoria l'intera tabella: aggiungi le parentesi. (a + b) * c è più chiaro che contare sul fatto che chi legge ricordi le regole.

Prossimo passo: la conversione di tipo

Hai visto sopra che (double)a / b ha forzato un intero in una divisione in virgola mobile. Quello è un cast: convertire deliberatamente un valore da un tipo a un altro. Nella prossima pagina vedremo gli strumenti di conversione di C++, dalle promozioni implicite a static_cast, e quando ciascuno è sicuro.