Arithmetische Operatoren

Ganzzahldivision & Modulo

• / bei Integer: Ergebnis wird zur Null hin abgeschnitten
• % erfordert Integer-Operanden; Vorzeichen = Vorzeichen des Dividenden (C99)

Priorität arithmetischer Operatoren

int x = 2 + 3 * 4;    /*  x = 14, nicht 20  */
int y = -2 + 3;       /*  y = 1             */

Was ist ein UPC?

Der Universal Product Code (UPC) ist der Strichcode auf Produkten in Nordamerika.

• 12 Stellen: Hersteller-ID + Produkt-ID + Prüfziffer
• Die 12. Ziffer ist eine Prüfziffer — sie wird aus den ersten 11 berechnet
• Zweck: fehlerhafte Scans erkennen (z. B. wenn der Scanner eine Ziffer falsch liest)

Programm: UPC-Prüfziffer

#include <stdio.h>
int main(void)
{
    int d, i1, i2, i3, i4, i5, j1, j2, j3, j4, j5, total;
    printf("Erste Ziffer:         "); scanf("%1d", &d);
    printf("Erste Fünfergruppe:   "); scanf("%1d%1d%1d%1d%1d",
                                           &i1,&i2,&i3,&i4,&i5);
    printf("Zweite Fünfergruppe:  "); scanf("%1d%1d%1d%1d%1d",
                                           &j1,&j2,&j3,&j4,&j5);
    total = 3*d  + i1 + 3*i2 + i3 + 3*i4 + i5 +
            3*j1 + j2 + 3*j3 + j4 + 3*j5;
    printf("Prüfziffer: %d\n", 9 - ((total - 1) % 10));
    return 0;
}

UPC — Algorithmus

• Ungerade Positionen (1., 3., 5., 7., 9., 11.) × 3
• Gerade Positionen (2., 4., 6., 8., 10.) × 1
• Alles addieren → total
• Prüfziffer: 9 - ((total - 1) % 10)

Zuweisungsoperatoren

Einfache Zuweisung

v = e;   /* speichert Wert von e in v */

• v muss ein lvalue sein — eine adressierbare Speicherstelle
• Zuweisung ist selbst ein Ausdruck und hat den Wert von e

i = j = k = 0;           /* Kette: von rechts nach links */
printf("%d\n", i = 5);   /* gibt 5 aus               */

Zusammengesetzte Zuweisungen

Inkrement & Dekrement

int i = 5;
printf("%d\n", ++i);   /* 6  — i ist 6  */
printf("%d\n", i++);   /* 6  — i ist 7  */
printf("%d\n", i);     /* 7             */

Präfix vs. Postfix — Vergleich

int i = 3, j;

j = ++i;   /* i wird 4, j = 4  (Präfix: erst erhöhen)      */
j = i++;   /* j = 4, dann i wird 5  (Postfix: erst lesen)  */

Priorität & Assoziativität (Vollständig)

Ausdrücke vollständig klammern

Ausgangsausdruck:

a = b += c++ - d + --e / -f

• Postfix c++: a = b += (c++) - d + --e / -f
• Präfix / Unär: a = b += (c++) - d + (--e) / (-f)
• Division: a = b += (c++) - d + ((--e) / (-f))
• Subtraktion, Addition: a = b += (((c++) - d) + ((--e) / (-f)))
• Zuweisung (rechts): (a = (b += (((c++) - d) + ((--e) / (-f)))))

Auswertungsreihenfolge

Priorität legt die Struktur fest. Die Reihenfolge der Auswertung ist meist undefiniert.

(a + b) * (c - d)
/* C wertet (a+b) und (c-d) in unbekannter Reihenfolge aus! */

a = 5;
c = (b = a + 2) - (a = 1);  /* Nicht vorhersagbar! */

Undefiniertes Verhalten

C kennt drei Kategorien:

• Definiert — Ergebnis ist immer vorhersagbar
• Implementierungsdefiniert — Compiler entscheidet, aber muss dokumentieren
• Undefiniert — Alles kann passieren: falsches Ergebnis, Absturz, Datenverlust

i = 2;
j = i * i++;   /* SCHLECHT: j könnte 4 oder 6 sein */

Ausdrucksanweisungen

In C kann jeder Ausdruck durch ; zur Anweisung werden.

i = 1;       /* sinnvoll: Zuweisung hat Nebeneffekt     */
i--;         /* sinnvoll: Dekrement hat Nebeneffekt     */
i * j - 1;  /* sinnlos:  kein Nebeneffekt, Wert weg    */

Typische Tippfehler-Falle

i = j;    /* gemeint: Zuweisung       */
i + j;    /* versehentlich: sinnlos!  */

= und + liegen auf derselben Taste — leicht vertauscht.

Fragen & Antworten

Potenzieren in C?

• Kein **-Operator in C (anders als Python)
• Kleine Potenzen: wiederholte Multiplikation — i * i * i = i³
• Nichtganzzahlige Potenzen: pow() aus <math.h>

double x = i * i * i;           /* i hoch 3  */
double y = pow(2.0, 0.5);       /* Wurzel aus 2 ≈ 1.414  */

% auf float?

• % erfordert Integer-Operanden
• Für Gleitkomma: fmod() aus <math.h>

Fragen & Antworten

lvalues und rvalues

• lvalue: Ausdruck, der links von = stehen kann (hat eine Speicheradresse)
• rvalue: Ausdruck auf der rechten Seite (Wert, keine Adresse)

i = 5;        /* i ist lvalue, 5 ist rvalue           */
i + 1 = 5;   /* FEHLER: "lvalue required as..."      */

Fragen & Antworten

Wann wird bei i++ inkrementiert?

• Spätestens am Ende der Ausdrucksanweisung (Sequenzpunkt)
• Funktionsaufrufe sind Sequenzpunkte: alle Argumente vollständig ausgewertet vor dem Aufruf
• Innerhalb desselben Ausdrucks: Reihenfolge undefiniert

printf("%d %d\n", i++, i);   /* UNDEFINIERT */
i++;
printf("%d\n", i);            /* OK          */

Übungen — Arithmetik (4.1)

Welche Ausgabe erzeugen diese Fragmente? (i, j, k sind int)

Übungen — Division mit negativen Zahlen (C99)

Übungen — Zusammengesetzte Zuweisung (4.2) ★

Übungen — Inkrement/Dekrement (4.3)

Übungen — Inkrement/Dekrement ★ (4.3)

Zwei separate printf-Aufrufe — Sequenzpunkte trennen die Effekte.

Übungen — Klammern & Anweisungen

Programmierprojekte

Projekt 1 & 2: Ziffern umkehren

• Letzte Ziffer: n % 10
• Erste Ziffer: n / 10
• Ausgabe: printf("%d%d\n", n%10, n/10)

Programmierprojekte

Projekt 3: Umkehren ohne Arithmetik

Ziffern einzeln mit %1d einlesen, dann umgekehrt ausgeben:

Programmierprojekte

Projekt 4: Oktaldarstellung

• Letzte Oktalziffer: n % 8
• Nächste Stelle: n / 8 wiederholen
• 32767 = 2¹&sup5; − 1 — passt in 15 bit

Programmierprojekte

Projekt 5: UPC auf einmal eingeben

scanf("%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d",
      &d, &i1, &i2, &i3, &i4, &i5,
      &j1, &j2, &j3, &j4, &j5);

Programmierprojekte

Projekt 6: EAN-Prüfziffer

Europäische Artikelnummer (13 Stellen) — auf jedem deutschen Produkt:

• Summe 1: gerade Positionen (2., 4., 6., 8., 10., 12.) × 3
• Summe 2: ungerade Positionen (1., 3., 5., 7., 9., 11.) × 1
• Prüfziffer: 9 - ((gesamt - 1) % 10)