Operatory w C: arytmetyczne, logiczne i priorytety

Operatory to czasowniki języka C: biorą wartości i tworzą nowe. Jest ich około 40, ale kilkanaście obejmuje większość kodu, a dwa z nich mają pułapki na tyle ostre, że zasługują na osobne sekcje.

Operatory arytmetyczne

#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: dzielenie całkowite! */
    printf("a %% b  = %d\n", a % b);  /* 2: reszta */
    printf("-a     = %d\n", -a);      /* jednoargumentowy minus */
    return 0;
}

(%% w łańcuchu formatu wypisuje dosłowny znak procentu; samo % rozpoczęłoby specyfikator formatu.)

Pięć dwuargumentowych operatorów arytmetycznych to + - * / %, a do tego jednoargumentowy - do negacji i +, który w praktyce nic nie robi.

Pułapka dzielenia całkowitego

a / b dla dwóch liczb całkowitych wykonuje dzielenie całkowite i wyrzuca resztę. Nie ma zaokrąglania: wynik jest obcinany w stronę zera.

#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;      /* dzielenie odbywa się NAJPIERW, na intach */
    printf("zla srednia   = %f\n", wrong);   /* 3.000000 */
    return 0;
}

Ten ostatni przypadek to błąd, który dożywa produkcji. Przypisanie do double nie pomaga: dzielenie total / count jest już zakończone, i to jako int, zanim nastąpi przypisanie. Rozwiązaniem jest uczynienie jednego operandu zmiennoprzecinkowym wewnątrz wyrażenia, zwykle przez rzutowanie.

Dwie pokrewne zasady: dzielenie liczb całkowitych przez zero to niezdefiniowane zachowanie i zwykle kończy się awarią programu, a INT_MIN / -1 powoduje przepełnienie.

Operator modulo

% daje resztę i działa tylko na liczbach całkowitych:

#include <stdio.h>

int main(void) {
    for (int i = 1; i <= 10; i++) {
        if (i % 2 == 0) {
            printf("%d jest parzyste\n", i);
        } else {
            printf("%d jest nieparzyste\n", i);
        }
    }

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

Sprawdzanie parzystości przez x % 2 == 0 i zawijanie indeksu wokół tablicy przez % n to dwa codzienne zastosowania.

Dla liczb ujemnych % w C przyjmuje znak dzielnej:

#include <stdio.h>

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

Dlatego x % 2 == 1 to błędny test nieparzystości, gdy x może być ujemne: -7 % 2 to -1. Używaj zamiast tego x % 2 != 0.

Dla reszt zmiennoprzecinkowych % to błąd kompilacji; użyj fmod() z math.h.

Przypisanie i przypisanie złożone

= zapisuje wartość. Formy złożone łączą operację z zapisem:

#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 oznacza x = x + 5, ale oblicza x tylko raz, co ma znaczenie, gdy celem jest coś w rodzaju arr[compute_index()].

Przypisanie samo jest wyrażeniem, które daje przypisaną wartość, i dlatego działa a = b = c = 0 (przypisuje od prawej do lewej), a pomyłka = zamiast == kompiluje się po cichu.

Inkrementacja i dekrementacja

++ dodaje jeden, -- odejmuje jeden. Każdy ma formę przedrostkową i przyrostkową:

#include <stdio.h>

int main(void) {
    int i = 5;
    int a = i++;    /* a dostaje 5 (starą wartość), potem i staje się 6 */
    printf("przyrostkowo:  a = %d, i = %d\n", a, i);

    int j = 5;
    int b = ++j;    /* najpierw j staje się 6, potem b dostaje 6 */
    printf("przedrostkowo: b = %d, j = %d\n", b, j);

    int k = 5;
    k++;            /* jako osobna instrukcja identyczne z ++k */
    printf("instrukcja:    k = %d\n", k);
    return 0;
}

Jako osobne instrukcje obie formy są wymienne, a i++ to zwyczajowy wybór w nagłówku for bez głębszego powodu niż tradycja.

Nie wolno natomiast używać zmiennej więcej niż raz w wyrażeniu, w którym jest też modyfikowana:

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

C nie definiuje kolejności obliczania tych podwyrażeń, więc wynik nie jest tylko nieokreślony: niezdefiniowane jest zachowanie całego programu. Podziel instrukcję na dwie, a niejednoznaczność zniknie.

Operatory porównania

Jest ich sześć i wszystkie dają int: 1 dla prawdy i 0 dla fałszu.

#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;
}

To, że wynik jest zwykłym int, a nie osobnym typem logicznym, to cecha definiująca C; co z tego wynika, łącznie z błędem = zamiast ==, opisuje strona o wartościach logicznych w C.

Dwa błędy porównań są typowe dla C. Łączenie w łańcuch nie działa tak, jak sugeruje matematyka: if (1 < x < 10) jest zawsze prawdą, bo 1 < x daje 0 albo 1, a to jest potem porównywane z 10. Pisz if (x > 1 && x < 10). A porównywanie łańcuchów przez == porównuje wskaźniki, a nie tekst: używaj strcmp z string.h.

Operatory logiczne

#include <stdio.h>

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

    if (age >= 18 && has_license) {
        printf("Moze prowadzic\n");
    }

    if (age < 13 || age > 65) {
        printf("Bilet ulgowy\n");
    } else {
        printf("Pelna cena\n");
    }

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

&& to AND, || to OR, ! to NOT. Wszystkie trzy traktują każdą niezerową wartość jako prawdę.

Działają skrótowo: && zatrzymuje się, gdy tylko jeden operand jest fałszem, a ||, gdy tylko jeden jest prawdą. Reszta nigdy nie jest obliczana i to nie tylko optymalizacja: to gwarancja, na której można polegać dla bezpieczeństwa:

#include <stdio.h>

int is_safe(int *p) {
    /* Jeśli p to NULL, *p nigdy nie jest obliczane: && zatrzymuje się wcześniej. */
    return p != NULL && *p > 0;
}

int main(void) {
    int value = 7;
    printf("z prawdziwym wskaznikiem: %d\n", is_safe(&value));
    printf("z NULL:                   %d\n", is_safe(NULL));
    return 0;
}

Zamień kolejność tych dwóch testów, a wywołanie z NULL wyłuska wskaźnik pusty i się wysypie. Najpierw zabezpieczenie, potem użycie: kolejność w łańcuchu && jest częścią logiki.

Operator warunkowy

Jedyny trójargumentowy operator C wybiera między dwiema wartościami:

#include <stdio.h>

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

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

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

condition ? value_if_true : value_if_false. To wyrażenie, więc pasuje tam, gdzie instrukcja if nie może stać: w argumencie printf albo w inicjalizatorze. Niech będzie krótkie; zagnieżdżone warunki szybko stają się nieczytelne.

Operatory bitowe w skrócie

Działają na pojedynczych bitach liczby całkowitej:

#include <stdio.h>

int main(void) {
    unsigned int a = 12;   /* 1100 binarnie */
    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: odwraca każdy bit */
    printf("a << 2 = %u\n", a << 2);   /* 48: przesunięcie w górę, mnoży przez 4 */
    printf("a >> 2 = %u\n", a >> 2);   /* 3: przesunięcie w dół, dzieli przez 4 */
    return 0;
}

Służą do flag, masek i rejestrów sprzętowych. Dwie przestrogi: & i | to nie && i || (nie działają skrótowo i operują bit po bicie), a przesunięcie wartości ze znakiem albo przesunięcie o więcej niż szerokość typu jest niezdefiniowane. Do pracy na bitach używaj typów bez znaku.

Priorytety

Gdy wyrażenie nie ma nawiasów, o tym, co z czym się wiąże, decyduje ta tabela. Najwyższy priorytet jest pierwszy:

Praktyczne konsekwencje:

a + b * c       /* oznacza a + (b * c) */
a < b == c < d  /* oznacza (a < b) == (c < d): rzadko o to chodzi */
x & 1 == 0      /* oznacza x & (1 == 0), czyli x & 0: klasyczny błąd */
*p++            /* oznacza *(p++): wyłuskaj p, potem je przesuń */

Trzecią linię warto zapamiętać: == wiąże mocniej niż &, więc testy masek bitowych potrzebują nawiasów: (x & 1) == 0.

Nikt nie pamięta wszystkich piętnastu poziomów i nikt nie musi. Zapamiętaj, że * wygrywa z +, że porównania wygrywają z &&, a ten z ||, a wszystko inne dostaje nawiasy:

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

Ta linia ma nadmiarowe nawiasy i jest dzięki nim lepsza.