Operatori in C: aritmetici, logici e precedenza

Gli operatori sono i verbi del C: prendono dei valori e ne producono di nuovi. Ce ne sono una quarantina, ma una dozzina copre la maggior parte del codice, e due di questi nascondono trappole abbastanza insidiose da meritare una sezione a parte.

Operatori aritmetici

#include <stdio.h>

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

    printf("a + b  = %d\n", a + b);   /* 22 */
    printf("a - b  = %d\n", a - b);   /* 12 */
    printf("a * b  = %d\n", a * b);   /* 85 */
    printf("a / b  = %d\n", a / b);   /* 3, divisione intera! */
    printf("a %% b  = %d\n", a % b);  /* 2, il resto */
    printf("-a     = %d\n", -a);      /* meno unario */
    return 0;
}

(%% nella stringa di formato stampa un segno di percentuale letterale: un % da solo darebbe inizio a uno specificatore di formato.)

I cinque operatori aritmetici binari sono + - * / %, più il - unario per la negazione e il + unario, che in sostanza non fa nulla.

La trappola della divisione intera

a / b con due interi esegue una divisione intera e butta via il resto. Non c'è arrotondamento: il risultato viene troncato verso lo zero.

#include <stdio.h>

int main(void) {
    int total = 7, count = 2;

    printf("7 / 2         = %d\n", total / count);          /* 3 */
    printf("7 / 2.0       = %f\n", total / 2.0);            /* 3.5 */
    printf("(double)7 / 2 = %f\n", (double)total / count);  /* 3.5 */

    double wrong = total / count;      /* la divisione avviene PRIMA, tra int */
    printf("media sbagliata = %f\n", wrong);   /* 3.000000 */
    return 0;
}

Quest'ultimo caso è il bug che sopravvive fino in produzione. Assegnare a un double non aiuta: la divisione total / count è già conclusa, ed è già un int, prima che avvenga l'assegnazione. La soluzione è rendere un operando in virgola mobile dentro l'espressione, di solito con un cast.

Due regole collegate: dividere per zero con gli interi è comportamento indefinito e di solito fa andare in crash il programma, e INT_MIN / -1 va in overflow.

L'operatore modulo

% dà il resto e funziona solo con gli interi:

#include <stdio.h>

int main(void) {
    for (int i = 1; i <= 10; i++) {
        if (i % 2 == 0) {
            printf("%d e' pari\n", i);
        } else {
            printf("%d e' dispari\n", i);
        }
    }

    int seconds = 3725;
    printf("\n%d secondi = %dh %dm %ds\n",
           seconds, seconds / 3600, (seconds % 3600) / 60, seconds % 60);
    return 0;
}

Controllare x % 2 == 0 per la parità e usare % n per far ripartire un indice dall'inizio di un array sono i due usi quotidiani.

Con i numeri negativi, il % del C segue il segno del dividendo:

#include <stdio.h>

int main(void) {
    printf(" 7 %% 3 = %d\n",  7 % 3);   /*  1 */
    printf("-7 %% 3 = %d\n", -7 % 3);   /* -1, non 2 */
    printf(" 7 %% -3 = %d\n", 7 % -3);  /*  1 */
    return 0;
}

Quindi x % 2 == 1 è un test sbagliato per i dispari quando x può essere negativo: -7 % 2 vale -1. Usa invece x % 2 != 0.

Per i resti in virgola mobile, % è un errore di compilazione; usa fmod() di math.h.

Assegnazione e assegnazione composta

= memorizza un valore. Le forme composte combinano un'operazione con la memorizzazione:

#include <stdio.h>

int main(void) {
    int x = 10;

    x += 5;   printf("x += 5   -> %d\n", x);   /* 15 */
    x -= 3;   printf("x -= 3   -> %d\n", x);   /* 12 */
    x *= 2;   printf("x *= 2   -> %d\n", x);   /* 24 */
    x /= 4;   printf("x /= 4   -> %d\n", x);   /* 6  */
    x %= 4;   printf("x %%= 4   -> %d\n", x);  /* 2  */
    return 0;
}

x += 5 significa x = x + 5, ma valuta x una sola volta, il che conta quando la destinazione è qualcosa come arr[compute_index()].

L'assegnazione è a sua volta un'espressione che produce il valore assegnato, ed è per questo che a = b = c = 0 funziona (assegna partendo dall'ultimo) e che l'errore = al posto di == compila in silenzio.

Incremento e decremento

++ aggiunge uno, -- sottrae uno. Ognuno ha una forma prefissa e una postfissa:

#include <stdio.h>

int main(void) {
    int i = 5;
    int a = i++;    /* a riceve 5 (il vecchio valore), poi i diventa 6 */
    printf("postfisso: a = %d, i = %d\n", a, i);

    int j = 5;
    int b = ++j;    /* prima j diventa 6, poi b riceve 6 */
    printf("prefisso:  b = %d, j = %d\n", b, j);

    int k = 5;
    k++;            /* come istruzione a se', identico a ++k */
    printf("istruzione: k = %d\n", k);
    return 0;
}

Come istruzione a sé le due forme sono intercambiabili, e i++ è la scelta convenzionale nell'intestazione di un for per nessun motivo più profondo della tradizione.

Quello che non devi fare è usare una variabile più di una volta in un'espressione in cui viene anche modificata:

int i = 5;
int x = i++ + i++;      /* comportamento indefinito */
arr[i] = i++;           /* comportamento indefinito */
printf("%d %d", i++, i);/* comportamento indefinito */

Il C non definisce l'ordine in cui vengono valutate quelle sottoespressioni, quindi il risultato non è solo non specificato: il comportamento dell'intero programma è indefinito. Dividi l'istruzione in due e l'ambiguità sparisce.

Operatori di confronto

Sono sei, e producono tutti un int: 1 per vero e 0 per falso.

#include <stdio.h>

int main(void) {
    int a = 5, b = 8;

    printf("a == b : %d\n", a == b);   /* 0 */
    printf("a != b : %d\n", a != b);   /* 1 */
    printf("a <  b : %d\n", a <  b);   /* 1 */
    printf("a >  b : %d\n", a >  b);   /* 0 */
    printf("a <= 5 : %d\n", a <= 5);   /* 1 */
    printf("a >= 9 : %d\n", a >= 9);   /* 0 */
    return 0;
}

Il fatto che il risultato sia un semplice int invece di un tipo booleano dedicato è una caratteristica distintiva del C: vedi i booleani in C per le conseguenze, compreso il bug = al posto di ==.

Due errori di confronto sono tipici del C. Il concatenamento non funziona come suggerisce la matematica: if (1 < x < 10) è sempre vero, perché 1 < x vale 0 o 1 e poi quel valore viene confrontato con 10. Scrivi if (x > 1 && x < 10). E confrontare stringhe con == confronta i puntatori, non il testo: usa strcmp di string.h.

Operatori logici

#include <stdio.h>

int main(void) {
    int age = 25;
    int has_license = 1;

    if (age >= 18 && has_license) {
        printf("Puo' guidare\n");
    }

    if (age < 13 || age > 65) {
        printf("Biglietto ridotto\n");
    } else {
        printf("Prezzo intero\n");
    }

    printf("!has_license = %d\n", !has_license);   /* 0 */
    printf("!0 = %d\n", !0);                       /* 1 */
    return 0;
}

&& è AND, || è OR, ! è NOT. Tutti e tre considerano vero qualsiasi valore diverso da zero.

Sono a corto circuito: && si ferma appena un operando è falso, e || si ferma appena uno è vero. Il resto non viene mai valutato, e non è solo un'ottimizzazione: è una garanzia su cui puoi contare per la sicurezza:

#include <stdio.h>

int is_safe(int *p) {
    /* Se p e' NULL, *p non viene mai valutato: && si ferma prima. */
    return p != NULL && *p > 0;
}

int main(void) {
    int value = 7;
    printf("con un puntatore vero: %d\n", is_safe(&value));
    printf("con NULL:              %d\n", is_safe(NULL));
    return 0;
}

Inverti l'ordine di quei due test e la chiamata con NULL dereferenzia un puntatore nullo e va in crash. Prima la guardia, poi l'uso: l'ordine in una catena di && fa parte della logica.

L'operatore condizionale

L'unico operatore a tre operandi del C sceglie tra due valori:

#include <stdio.h>

int main(void) {
    int a = 12, b = 30;

    int max = (a > b) ? a : b;
    printf("max = %d\n", max);

    printf("%d element%s\n", a, (a == 1) ? "o" : "i");
    return 0;
}

condition ? value_if_true : value_if_false. È un'espressione, quindi sta dove un'istruzione if non può stare: dentro un argomento di printf, in un inizializzatore. Tienilo breve; i condizionali annidati diventano illeggibili in fretta.

Operatori bit a bit, in breve

Questi lavorano sui singoli bit di un intero:

#include <stdio.h>

int main(void) {
    unsigned int a = 12;   /* 1100 in binario */
    unsigned int b = 10;   /* 1010 */

    printf("a & b  = %u\n", a & b);    /* 8,  1000, AND */
    printf("a | b  = %u\n", a | b);    /* 14, 1110, OR  */
    printf("a ^ b  = %u\n", a ^ b);    /* 6,  0110, XOR */
    printf("~a     = %u\n", ~a);       /* NOT: inverte ogni bit */
    printf("a << 2 = %u\n", a << 2);   /* 48: spostamento verso l'alto, moltiplica per 4 */
    printf("a >> 2 = %u\n", a >> 2);   /* 3:  spostamento verso il basso, divide per 4 */
    return 0;
}

Si usano per flag, maschere e registri hardware. Due avvertenze: & e | non sono && e || (non vanno a corto circuito e operano bit per bit), e spostare un valore con segno, o spostare di più della larghezza del tipo, è indefinito. Per lavorare sui bit usa tipi senza segno.

Precedenza

Quando un'espressione non ha parentesi, questa tabella decide cosa si lega a cosa. Prima la precedenza più alta:

Le conseguenze pratiche:

a + b * c       /* significa a + (b * c) */
a < b == c < d  /* significa (a < b) == (c < d), raramente quello che volevi */
x & 1 == 0      /* significa x & (1 == 0), cioe' x & 0: un bug classico */
*p++            /* significa *(p++): dereferenzia p, poi lo fa avanzare */

Quella terza riga vale la pena impararla a memoria: == si lega più strettamente di &, quindi i test sulle maschere di bit vogliono le parentesi: (x & 1) == 0.

Nessuno ricorda tutti e quindici i livelli, e a nessuno serve. Impara che * batte +, che i confronti battono && che batte ||, e metti le parentesi a tutto il resto:

if ((flags & MASK) != 0 && (count > 0 || force)) { ... }

Quella riga ha parentesi ridondanti, ed è migliore proprio per questo.