Operatoren in C: Arithmetik, Logik und Vorrang

Operatoren sind die Verben von C: Sie nehmen Werte entgegen und erzeugen neue. Es gibt rund 40 davon, aber ein Dutzend deckt den meisten Code ab, und zwei davon haben Fallen, die scharf genug für eigene Abschnitte sind.

Arithmetische Operatoren

#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  - Ganzzahldivision! */
    printf("a %% b  = %d\n", a % b);  /* 2  - der Rest */
    printf("-a     = %d\n", -a);      /* unaeres Minus */
    return 0;
}

(%% in der Formatzeichenkette gibt ein wörtliches Prozentzeichen aus - ein % allein würde eine Formatangabe beginnen.)

Die fünf binären arithmetischen Operatoren sind + - * / %, dazu das unäre - zur Negation und +, das im Wesentlichen nichts tut.

Die Falle der Ganzzahldivision

a / b mit zwei Ganzzahlen führt eine Ganzzahldivision aus und wirft den Rest weg. Es wird nicht gerundet - das Ergebnis wird Richtung null abgeschnitten.

#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;      /* die Division passiert ZUERST, als ints */
    printf("falscher Durchschnitt = %f\n", wrong);   /* 3.000000 */
    return 0;
}

Der letzte Fall ist der Bug, der es bis in die Produktion schafft. Einem double zuzuweisen hilft nicht: Die Division total / count ist bereits abgeschlossen und bereits ein int, bevor die Zuweisung passiert. Die Lösung ist, einen Operanden innerhalb des Ausdrucks zu einem Gleitkommawert zu machen, meist mit einem Cast.

Zwei verwandte Regeln: Eine Ganzzahldivision durch null ist undefiniertes Verhalten und bringt das Programm typischerweise zum Absturz, und INT_MIN / -1 läuft über.

Der Modulo-Operator

% liefert den Rest und funktioniert nur auf Ganzzahlen:

#include <stdio.h>

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

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

x % 2 == 0 auf Geradheit zu prüfen und % n zu benutzen, um einen Index in einem Array umlaufen zu lassen, sind die beiden alltäglichen Verwendungen.

Bei negativen Zahlen folgt Cs % dem Vorzeichen des Dividenden:

#include <stdio.h>

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

x % 2 == 1 ist also ein kaputter Test auf Ungeradheit, wenn x negativ sein kann - -7 % 2 ist -1. Nimm stattdessen x % 2 != 0.

Für Gleitkommareste ist % ein Übersetzungsfehler; nimm fmod() aus math.h.

Zuweisung und zusammengesetzte Zuweisung

= speichert einen Wert. Die zusammengesetzten Formen verbinden eine Operation mit dem Speichern:

#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 bedeutet x = x + 5, wertet x aber nur einmal aus - was zählt, wenn das Ziel etwas wie arr[compute_index()] ist.

Die Zuweisung ist selbst ein Ausdruck, der den zugewiesenen Wert liefert, weshalb a = b = c = 0 funktioniert (es weist von rechts nach links zu) und weshalb der =-statt-==-Fehler stillschweigend kompiliert.

Inkrement und Dekrement

++ addiert eins, -- zieht eins ab. Jedes kommt in einer Präfix- und einer Postfixform:

#include <stdio.h>

int main(void) {
    int i = 5;
    int a = i++;    /* a bekommt 5 (den alten Wert), dann wird i zu 6 */
    printf("Postfix: a = %d, i = %d\n", a, i);

    int j = 5;
    int b = ++j;    /* j wird zuerst 6, dann bekommt b den Wert 6 */
    printf("Praefix: b = %d, j = %d\n", b, j);

    int k = 5;
    k++;            /* als eigenstaendige Anweisung identisch mit ++k */
    printf("Anweisung: k = %d\n", k);
    return 0;
}

Als eigenständige Anweisung sind die beiden austauschbar, und i++ ist im Kopf einer for-Schleife die übliche Wahl, aus keinem tieferen Grund als der Tradition.

Was du nicht tun darfst, ist eine Variable mehr als einmal in einem Ausdruck zu benutzen, in dem sie auch verändert wird:

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

C legt die Reihenfolge nicht fest, in der diese Teilausdrücke ausgewertet werden, das Ergebnis ist also nicht bloß unspezifiziert - das Verhalten des gesamten Programms ist undefiniert. Teile die Anweisung in zwei, und die Mehrdeutigkeit verschwindet.

Vergleichsoperatoren

Sechs Stück, und alle liefern ein int: 1 für wahr und 0 für falsch.

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

Dass das Ergebnis ein schlichtes int und kein eigener Wahrheitstyp ist, ist ein prägendes Merkmal von C - siehe Booleans in C für das, was daraus folgt, einschließlich des =-statt-==-Bugs.

Zwei Vergleichsfehler sind C-spezifisch. Verketten funktioniert nicht so, wie die Mathematik es nahelegt: if (1 < x < 10) ist immer wahr, denn 1 < x ergibt 0 oder 1, und das wird dann mit 10 verglichen. Schreibe if (x > 1 && x < 10). Und Zeichenketten mit == zu vergleichen vergleicht Zeiger, nicht Text - nimm strcmp aus string.h.

Logische Operatoren

#include <stdio.h>

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

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

    if (age < 13 || age > 65) {
        printf("Ermaessigtes Ticket\n");
    } else {
        printf("Voller Preis\n");
    }

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

&& ist UND, || ist ODER, ! ist NICHT. Alle drei behandeln jeden Wert ungleich null als wahr.

Sie werten abkürzend aus: && hört auf, sobald ein Operand falsch ist, und || hört auf, sobald einer wahr ist. Der Rest wird nie ausgewertet, und das ist nicht nur eine Optimierung - es ist eine Garantie, auf die du dich aus Sicherheitsgründen verlassen kannst:

#include <stdio.h>

int is_safe(int *p) {
    /* Wenn p NULL ist, wird *p nie ausgewertet - das && stoppt vorher. */
    return p != NULL && *p > 0;
}

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

Tausche die Reihenfolge dieser beiden Prüfungen, und der NULL-Aufruf dereferenziert einen Nullzeiger und stürzt ab. Zuerst absichern, dann benutzen - die Reihenfolge in einer &&-Kette gehört zur Logik.

Der Bedingungsoperator

Cs einziger dreistelliger Operator wählt zwischen zwei Werten:

#include <stdio.h>

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

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

    printf("%d Artikel\n", a);
    printf("%s\n", (a == 1) ? "genau einer" : "mehrere");
    return 0;
}

bedingung ? wert_wenn_wahr : wert_wenn_falsch. Es ist ein Ausdruck, passt also dorthin, wo eine if-Anweisung nicht hinpasst - in ein printf-Argument, in einen Initialisierer. Halte ihn kurz; verschachtelte Bedingungsoperatoren werden schnell unlesbar.

Bitweise Operatoren, kurz gefasst

Diese arbeiten auf den einzelnen Bits einer Ganzzahl:

#include <stdio.h>

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

    printf("a & b  = %u\n", a & b);    /* 8  - 1000, UND */
    printf("a | b  = %u\n", a | b);    /* 14 - 1110, ODER */
    printf("a ^ b  = %u\n", a ^ b);    /* 6  - 0110, XOR */
    printf("~a     = %u\n", ~a);       /* NICHT - kippt jedes Bit */
    printf("a << 2 = %u\n", a << 2);   /* 48 - hoch schieben, mal 4 */
    printf("a >> 2 = %u\n", a >> 2);   /* 3  - runter schieben, durch 4 */
    return 0;
}

Sie werden für Flags, Masken und Hardwareregister benutzt. Zwei Warnungen: & und | sind nicht && und || (sie werten nicht abkürzend aus und arbeiten Bit für Bit), und einen vorzeichenbehafteten Wert zu schieben oder weiter als die Breite des Typs zu schieben ist undefiniert. Nimm für Bitarbeit vorzeichenlose Typen.

Vorrang

Wenn ein Ausdruck keine Klammern hat, entscheidet diese Tabelle, was woran bindet. Höchster Vorrang zuerst:

Die praktischen Folgen:

a + b * c       /* bedeutet a + (b * c) */
a < b == c < d  /* bedeutet (a < b) == (c < d) - selten das Gemeinte */
x & 1 == 0      /* bedeutet x & (1 == 0), also x & 0 - ein klassischer Bug */
*p++            /* bedeutet *(p++) - p dereferenzieren, dann weiterrücken */

Die dritte Zeile ist merkenswert: == bindet stärker als &, Bitmasken-Tests brauchen also Klammern - (x & 1) == 0.

Niemand merkt sich alle fünfzehn Stufen, und niemand muss es. Lerne, dass * + schlägt, dass Vergleiche && schlagen, das || schlägt, und dass alles andere Klammern bekommt:

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

Diese Zeile hat überflüssige Klammern und ist dadurch besser.