Unterrichtsmaterial

• In den frühen 1970er Jahren bei Bell Labs als Nebenprodukt von UNIX entwickelt
• Ken Thompson schrieb UNIX zunächst in Assembler; wollte eine höhere Programmiersprache
• Entwicklungskette: BCPL → B → NB → C
• 1973 wurde UNIX komplett in C umgeschrieben, was die Portierbarkeit stark verbesserte

• 1978: K&R-Buch (“The C Programming Language”) wurde zum inoffiziellen Standard
• 1989/1990: Erster offizieller ANSI/ISO-Standard → C89/C90
• 1999: Neuer Standard mit zusätzlichen Features → C99
• Vor C89 gab es viele inkompatible Dialekte, was die Portierbarkeit gefährdete

• C++ erweitert C um objektorientierte Programmierung (Klassen, etc.)
• Java und C# basieren auf C++ und erben viele C-Eigenschaften
• Perl übernahm im Laufe der Zeit viele C-Features
• Wer C lernt, versteht die Grundlagen all dieser Sprachen besser

• Effizienz: C-Programme laufen schnell und benötigen wenig Speicher
• Portierbarkeit: Derselbe Code läuft auf PCs bis hin zu Supercomputern
• Mächtigkeit: Viele Datentypen und Operatoren; viel mit wenig Code erreichbar
• Flexibilität: Kaum Einschränkungen; z.B. kann ein char zu einem int addiert werden
• Standardbibliothek: Hunderte nützliche Funktionen für I/O, Strings, Speicher, etc.

• Fehleranfällig: Viele Fehler werden erst zur Laufzeit entdeckt, nicht beim Kompilieren
  • Beispiel: Ein fehlendes & bei scanf führt zum Absturz, wird aber nicht immer erkannt
• Schwer lesbar: Sehr kompakter, knapper Stil; absichtliche Kürze aus historischen Gründen
  • Beispiel: -+i ist gültiger Ausdruck (unäres Minus und Plus)
• Schwer wartbar: Großen C-Programmen fehlen Strukturierungsmittel wie Klassen oder Pakete

• Mit Hilfe von GCC!
• gcc -o programmname programmcode.c

• ./programmname

• Ursprünglich “GNU C Compiler”, heute “GNU Compiler Collection”
• Kompiliert viele Sprachen: C, C++, Java, Fortran, Ada, Objective-C

• “GNU’s Not UNIX!” (rekursives Akronym), ausgesprochen “guh-NEW”
• Projekt der Free Software Foundation von Richard M. Stallman
• Protest gegen Einschränkungen lizenzierter UNIX-Software
• GNU-Software (inkl. GCC) ist ein wesentlicher Bestandteil von Linux

• Kostenlos, hochwertig und auf vielen Plattformen verfügbar
• Erzeugt Code für viele verschiedene CPUs
• Unterstützt viele Programmiersprachen

Nützliche Compiler-Optionen:

-Wall

Aktiviert alle Warnmeldungen

-W

Zusätzliche Warnungen über -Wall hinaus

-pedantic

Alle vom C-Standard geforderten Warnungen; lehnt nicht-standardkonforme Features ab

-ansi

Deaktiviert GCC-spezifische Features; aktiviert Standard-Features

-std=c89 / -std=c99

Legt die zu verwendende C-Version fest

Typische Kombination:

gcc -O -Wall -W -pedantic -ansi -std=c99 -o programm programm.c

• Historischer Grund: Entwicklung auf einem PDP-11 mit Fernschreiber (10 Zeichen/Sekunde)
• Möglichst wenige Zeichen zu tippen war damals ein echter Vorteil
• Daher { und } statt begin~/~end, int statt integer, usw.

• Ja, innerhalb von main sind beide gleichwertig
• Beide beenden das Programm und geben den Wert 0 an das Betriebssystem zurück
• Welche Variante man wählt, ist Geschmackssache

• Das Programm wird trotzdem beendet
• In C99 wird implizit 0 zurückgegeben
• In C89 wird ein unbestimmter Wert zurückgegeben
• Viele Compiler erzeugen eine Warnung

• Nein: laut C-Standard wird jeder Kommentar durch ein einzelnes Leerzeichen ersetzt
• Alter Trick a/**/b funktioniert daher nicht; der Compiler sieht a b (ungültig)

• Oft führt er zu einem Kompilierfehler, weil er Code “verschluckt”
• IDEs färben Kommentare oft farblich ein; falsch gefärbter Code zeigt das Problem
• Debugger (zeilenweises Durchgehen) oder lint können helfen

• Nein: /* ... */ Kommentare können nicht verschachtelt werden
• Das erste */ schließt den Kommentar, egal wie viele /* davor standen
• C99-Kommentare (//) können jedoch innerhalb von /* */ verwendet werden
• Das ist ein weiterer Vorteil von //-Kommentaren

• Direktiven beginnen mit # und werden vor der Kompilierung verarbeitet
• #include <stdio.h> bindet die Standard-I/O-Bibliothek ein (nötig für printf/scanf)
• main() ist die einzige Pflichtfunktion; sie wird automatisch beim Programmstart aufgerufen
• Rückgabewert return 0; signalisiert dem Betriebssystem: Programm erfolgreich beendet
• Anweisungen enden mit Semikolon; Direktiven nicht

Beispiel: minimales C-Programm

#include <stdio.h>
int main(void)
{
    printf("Hallo, Welt!\n");
    return 0;
}

• Variablen müssen vor ihrer Verwendung deklariert werden
• int speichert ganze Zahlen (typisch bis ±2.147.483.647)
• float speichert Dezimalzahlen, aber mit möglichem Rundungsfehler
  • Beispiel: 0.1f kann intern als 0.09999999... gespeichert sein
• Mehrere Variablen gleichen Typs können zusammen deklariert werden

int hoehe = 8, laenge = 12, breite = 10;
float gewinn = 2150.48f;  /* f am Ende wichtig bei float-Zuweisung */

• %d für int, %f für float, %.2f für float mit 2 Nachkommastellen
• \n für Zeilenumbruch, \t für Tabulator
• Feldbreite und Ausrichtung steuerbar: %5d (rechtsbündig), %-5d (linksbündig)

int volumen = 960;
float preis = 13.5f;
printf("Volumen: %d Kubikzoll\n", volumen);
printf("Preis: %8.2f Euro\n", preis);  /* rechtsbündig, 2 Nachkommastellen */

• & vor dem Variablennamen ist (meistens) Pflicht; fehlt es, droht Absturz
• %d für int, %f für float
• scanf überspringt Leerzeichen automatisch beim Suchen nach Zahlen

int hoehe;
printf("Hoehe eingeben: ");
scanf("%d", &hoehe);  /* & nicht vergessen! */

• Mit #define werden Konstanten definiert; der Präprozessor ersetzt den Namen vor der Kompilierung
• Konvention: Großbuchstaben für Konstantennamen
• Ausdrücke in Klammern setzen, um Vorrangfehler zu vermeiden

#define GEFRIERPUNKT 32.0f
#define UMRECHNUNGSFAKTOR (5.0f / 9.0f)  /* Klammern wichtig! */
/* ohne Klammern: 5.0f / 9.0f * (fahrenheit - 32.0f) → falsches Ergebnis */

celsius = (fahrenheit - GEFRIERPUNKT) * UMRECHNUNGSFAKTOR;

• Bezeichner dürfen Buchstaben, Ziffern und Unterstriche enthalten; müssen mit Buchstabe oder Unterstrich beginnen
• C unterscheidet Groß- und Kleinschreibung: job, Job, JOB sind drei verschiedene Bezeichner
• Schlüsselwörter wie int, float, return, if, while sind reserviert und dürfen nicht als Namen verwendet werden
• Ungültige Bezeichner: 10mal (beginnt mit Ziffer), get-next (enthält Minus)

• Kurzform für “floating-point” (Gleitkomma)
• Zahl wird in zwei Teilen gespeichert: Mantisse und Exponent
• Beispiel: 12.0 wird intern als 1.5 × 2³ gespeichert
• Andere Sprachen nennen diesen Typ real

• Eine Dezimalzahl ohne f hat den Typ double (doppelte Genauigkeit)
• double kann größer sein als float; daher Warnung möglich bei Zuweisung ohne f
• Beispiel: profit = 2150.48f; ist korrekt; profit = 2150.48; kann Warnung erzeugen

• Technisch nein, aber Compiler müssen nur eine bestimmte Anzahl Zeichen merken
• C89: erste 31 Zeichen signifikant (63 in C99)
• Bei externer Verlinkung (z.B. Funktionsnamen): in C89 nur 6 Zeichen, Groß-/Kleinschreibung ggf. egal
• In der Praxis sind moderne Compiler großzügiger; sehr kurze Namen sind das eigentliche Problem

• Zu wenig: Einrückung kaum erkennbar
• Zu viel: Zeilen laufen aus dem Bild
• Studien: optimale Einrückung sind 3 Leerzeichen
• Im Buch werden 2 Leerzeichen verwendet, damit der Code in die Seitenränder passt

Erstelle und starte das “hello, world”-Programm. Gibt es Compiler-Warnungen?

#include <stdio.h>
int main(void)
{
    printf("hello, world\n");
}

Gegeben folgendes Programm:

#include <stdio.h>
int main(void)
{
    printf("Parkinson's Law:\nWork expands so as to ");
    printf("fill the time\n");
    printf("available for its completion.\n");
    return 0;
}

• (a) Identifiziere die Direktiven und Anweisungen im Programm
• (b) Welche Ausgabe erzeugt das Programm?

Vereinfache das dweight.c-Programm:

/* Computes the dimensional weight of a 12" x 10" x 8" box */

#include <stdio.h>

int main(void) {
    int height, length, width, volume, weight;

    height = 8;
    length = 12;
    width = 10;
    volume = height * length * width;
    weight = (volume + 165) / 166;

    printf("Dimensions: %dx%dx%dx\n", length, width, height);
    printf("Volume (cubic inches): %d\n", volume);
    printf("Dimensional weight (pounds): %d\n", weight);

    return 0;
}

• (1) Ersetze die Zuweisungen an height, length und width durch Initialisierungen
• (2) Entferne die Variable weight und berechne (volume + 165) / 166 direkt in printf

Schreibe ein Programm, das mehrere int- und float-Variablen deklariert, ohne sie zu initialisieren, und dann ihre Werte ausgibt. Gibt es ein Muster bei den Werten?

Welche der folgenden sind keine gültigen C-Bezeichner?

• (a) 100_bottles → ungültig (beginnt mit Ziffer)
• (b) _100_bottles → gültig
• (c) one__hundred__bottles → gültig
• (d) bottles_by_the_hundred_ → gültig

Warum ist es keine gute Idee, mehrere aufeinanderfolgende Unterstriche in einem Bezeichner zu verwenden (z.B. current___balance)?

• Solche Namen sind für die Implementierung (Compiler/Bibliotheken) reserviert
• Kann zu Konflikten mit internen Compiler-Bezeichnern führen

Welche der folgenden sind Schlüsselwörter in C?

• (a) for → Schlüsselwort
• (b) If → kein Schlüsselwort (C unterscheidet Groß-/Kleinschreibung; if wäre eines)
• (c) main → kein Schlüsselwort (reservierter Funktionsname, aber kein Keyword)
• (d) printf → kein Schlüsselwort (Bibliotheksfunktion)
• (e) while → Schlüsselwort

Schreibe ein Programm, das folgendes Bild mit printf ausgibt:

          *
         *
        *
 *     *
  *   *
    *

Schreibe ein Programm, das das Volumen einer Kugel mit Radius 10 berechnet. Formel: v = 4/3 * π * r³

• Schreibe 4/3 als 4.0f/3.0f (sonst ganzzahlige Division → Ergebnis 1)
• r³ als r * r * r (kein Potenzoperator in C)

Erweitere Projekt 2: Der Benutzer gibt den Radius selbst ein.

Schreibe ein Programm, das einen Betrag einliest und ihn mit 5% Mehrwertsteuer ausgibt:

Betrag eingeben: 100.00
Mit Steuer: $105.00

Schreibe ein Programm, das x einliest und folgenden Ausdruck berechnet: 3x⁵ + 2x⁴ - 5x³ - x² + 7x - 6 Hinweis: Potenzen durch wiederholte Multiplikation berechnen (x*x*x für x³)

Wie Projekt 5, aber mit Horner-Schema: ((((3x + 2)x - 5)x - 1)x + 7)x - 6 Vorteil: weniger Multiplikationen nötig

Schreibe ein Programm, das einen Dollar-Betrag einliest und mit möglichst wenigen Scheinen ($20, $10, $5, $1) herausgibt:

Betrag eingeben: 93
$20-Scheine: 4
$10-Scheine: 1
 $5-Scheine: 0
 $1-Scheine: 3

Hinweis: Nur ganzzahlige Arithmetik verwenden

Schreibe ein Programm, das den Restbetrag eines Darlehens nach den ersten drei monatlichen Zahlungen berechnet und anzeigt:

Darlehensbetrag eingeben: 20000.00
Zinssatz eingeben: 6.0
Monatliche Rate eingeben: 386.66
Restbetrag nach 1. Zahlung: $19713.34
Restbetrag nach 2. Zahlung: $19425.25
Restbetrag nach 3. Zahlung: $19135.71

Hinweis: Monatszins = Jahreszins / 12 / 100; Restbetrag = Restbetrag - Rate + Restbetrag * Monatszins

• printf gibt den Inhalt eines Formatstrings aus, wobei Werte an bestimmten Stellen eingefügt werden
• Syntax: printf(formatstring, ausdruck1, ausdruck2, ...);
• Keine Begrenzung der Anzahl an Werten in einem einzelnen printf-Aufruf
• Der Compiler prüft nicht, ob Umwandlungsspezifikation und Datentyp zusammenpassen

• Allgemeine Form: %m.pX oder %-m.pX (m und p sind optional)
• m = minimale Feldbreite: Mindestanzahl der Zeichen; Wert wird rechtsbündig ausgegeben
  • %4d zeigt 123 als ·123 (·= Leerzeichen)
  • Wenn der Wert breiter ist als m, wird das Feld automatisch erweitert
  • %-4d ergibt linksbündige Ausgabe: 123·
• p = Genauigkeit: Bedeutung hängt vom Umwandlungsspezifizierer ab

Beispiel: mehrzeiliger Header mit Tabs

printf("Item\tUnit\tPurchase\n\tPrice\tDate\n");

Ausgabe:

Item    Unit    Purchase
        Price   Date

• scanf liest Eingaben gemäß einem Formatstring und speichert sie in Variablen
• & vor dem Variablennamen ist (meistens) Pflicht; fehlt es, droht Absturz oder undefiniertes Verhalten
• scanf überspringt Whitespace (Leerzeichen, Tabs, Zeilenumbrüche) beim Suchen nach Zahlen

int i, j;
float x, y;
scanf("%d%d%f%f", &i, &j, &x, &y);
/* Eingabe: 1 -20 .3 -4.0e3
   → i=1, j=-20, x=0.3, y=-4000.0 */

• scanf liest die Eingabe als durchgehenden Zeichenstrom
• Bei %d: sucht Ziffer, Plus- oder Minuszeichen; liest Ziffern bis ein Nicht-Ziffern-Zeichen kommt
• Bei %f~/~%e~/~%g: sucht optionales Vorzeichen, Ziffern (evtl. mit Dezimalpunkt), optionalen Exponenten
• Nicht passende Zeichen werden “zurückgelegt” für den nächsten scanf-Aufruf
• %e, %f und %g sind bei scanf austauschbar (alle folgen denselben Regeln)

Beispiel für Zurücklegen:

scanf("%d%d%f%f", &i, &j, &x, &y);
/* Eingabe: 1-20.3-4.0e3
   → i=1, j=-20, x=0.3, y=-4000.0
   scanf legt '-', '.' usw. zurück, wenn sie nicht zum aktuellen Typ passen */

• Leerzeichen im Formatstring: überspringt beliebig viele Whitespace-Zeichen der Eingabe
• Andere Zeichen (z.B. /, ,): müssen exakt in der Eingabe vorkommen

scanf("%d/%d", &monat, &tag);       /* erwartet z.B. 2/17 */
scanf("%d,%d", &i, &j);             /* erwartet z.B. 4,28 */

• Wenn das Zeichen nicht passt, bricht scanf sofort ab

• & in printf ist ein Fehler: printf("%d", &i); → gibt seltsame Zahl aus statt den Wert von i
• \n am Ende eines scanf-Formatstrings ist fast immer falsch: scanf("%d\n", &i);
  • \n wirkt in scanf wie ein Leerzeichen; Programm hängt, bis Benutzer ein nicht-leeres Zeichen eingibt
• Gewöhnliche Zeichen im scanf-Format müssen in der Eingabe übereinstimmen:
  • scanf("%d, %d", &i, &j); erwartet ein Komma zwischen den Zahlen

/* addfrac.c */
/* Addiert zwei Brüche */
#include <stdio.h>

int main(void)
{
    int num1, denom1, num2, denom2, result_num, result_denom;

    printf("Ersten Bruch eingeben: ");
    scanf("%d/%d", &num1, &denom1);

    printf("Zweiten Bruch eingeben: ");
    scanf("%d/%d", &num2, &denom2);

    result_num = num1 * denom2 + num2 * denom1;
    result_denom = denom1 * denom2;

    printf("Die Summe ist %d/%d\n", result_num, result_denom);

    return 0;
}

Beispielausgabe:

Ersten Bruch eingeben: 5/6
Zweiten Bruch eingeben: 3/4
Die Summe ist 38/24

Hinweis: Das Ergebnis wird nicht gekürzt.

• Bei printf: kein Unterschied
• Bei scanf: %d erkennt nur Dezimalzahlen; %i erkennt auch Oktal- (Präfix 0) und Hexadezimalzahlen (Präfix 0x)
• Falle: Wenn der Benutzer versehentlich eine führende 0 eingibt, interpretiert %i die Zahl als oktal
• Empfehlung: Bei %d bleiben

• Zwei aufeinanderfolgende %-Zeichen: %%
• Beispiel: printf("Gewinn: %d%%\n", gewinn); → Gewinn: 10%

• In C nicht definiert; hängt vom Betriebssystem ab
• Typisch: 8 Zeichen Abstand, aber keine Garantie

• Eingabe 23foo bei %d: scanf liest 23, foo bleibt für den nächsten Aufruf
• Eingabe foo bei %d: Variable bleibt undefiniert, foo bleibt im Puffer
• Prüfung des Rückgabewerts von scanf ermöglicht Fehlererkennung (Details in Kapitel 22)

• Eingaben werden nicht direkt gelesen, sondern in einem versteckten Puffer gespeichert
• scanf kann Zeichen zurück in den Puffer legen, damit sie beim nächsten Aufruf gelesen werden
• Details zur Eingabepufferung in Kapitel 22

• Eingabe 4,28 bei scanf("%d%d", &i, &j);: i = 4, j wird nicht gelesen (Komma passt nicht zu einer Zahl)
• Lösung: Komma im Formatstring angeben: scanf("%d,%d", &i, &j);

Welche Ausgabe erzeugen die folgenden printf-Aufrufe?

• (a) printf("%6d,%4d", 86, 1040); → ····86,1040
• (b) printf("%12.5e", 30.253); → ·3.02530e+01
• (c) printf("%.4f", 83.162); → 83.1620
• (d) printf("%-6.2g", .0000009979); → 1e-06·

Schreibe printf-Aufrufe, die eine float-Variable x in folgenden Formaten anzeigen:

• (a) Exponentialform; linksbündig in Feld der Breite 8; eine Nachkommastelle
• (b) Exponentialform; rechtsbündig in Feld der Breite 10; sechs Nachkommastellen
• (c) Dezimalform; linksbündig in Feld der Breite 8; drei Nachkommastellen
• (d) Dezimalform; rechtsbündig in Feld der Breite 6; keine Nachkommastellen

Sind die folgenden scanf-Formatstring-Paare gleichwertig? Falls nein, zeige den Unterschied.

• (a) "%d" vs. " %d" → gleichwertig (%d überspringt Whitespace automatisch)
• (b) "%d-%d-%d" vs. "%d -%d -%d" → nicht gleichwertig (Leerzeichen im Format überspringt beliebig viele Whitespace-Zeichen)
• (c) "%f" vs. "%f " → nicht gleichwertig (nachstehendes Leerzeichen lässt scanf auf weitere Eingabe warten)
• (d) "%f,%f" vs. "%f, %f" → gleichwertig (Leerzeichen vor %f redundant, da %f ohnehin Whitespace überspringt)

Angenommen, wir rufen auf:

scanf("%d%f%d", &i, &x, &j);

und der Benutzer gibt ein: 10.3 5 6

Ergebnis: i = 10, x = 0.3, j = 5

• scanf liest 10 für %d, stoppt am Punkt
• .3 wird als Float gelesen (%f)
• 5 wird für das zweite %d gelesen
• 6 bleibt im Puffer

Angenommen, wir rufen auf:

scanf("%f%d%f", &x, &i, &y);

und der Benutzer gibt ein: 12.3 45.6 789

Ergebnis: x = 12.3, i = 45, y = 0.6

• 12.3 wird als Float für x gelesen
• 45 wird als Integer für i gelesen, scanf stoppt am Punkt
• .6 wird als Float für y gelesen
• 789 bleibt im Puffer

Wie kann das addfrac.c-Programm geändert werden, damit der Benutzer Leerzeichen vor und nach dem /-Zeichen eingeben darf?

Lösung: Leerzeichen im Formatstring einfügen:

scanf("%d / %d", &num, &denom);

Schreibe ein Programm, das ein Datum im Format mm/dd/yyyy einliest und als yyyymmdd ausgibt:

Datum eingeben (mm/dd/yyyy): 2/17/2011
Eingegebenes Datum: 20110217

Schreibe ein Programm, das Produktinformationen vom Benutzer einliest und formatiert ausgibt:

Artikelnummer eingeben: 583
Stückpreis eingeben: 13.5
Kaufdatum eingeben (mm/dd/yyyy): 10/24/2010

Item            Unit            Purchase
                Price           Date
583             $  13.50        10/24/2010

• Artikelnummer und Datum linksbündig; Preis rechtsbündig
• Beträge bis $9999.99 zulassen
• Hinweis: Tabs (\t) für Spaltenausrichtung verwenden

Schreibe ein Programm, das eine ISBN-13 einliest und in ihre Bestandteile zerlegt:

ISBN eingeben: 978-0-393-97950-3
GS1-Präfix: 978
Gruppenkennung: 0
Verlagscode: 393
Titelnummer: 97950
Prüfziffer: 3

Hinweis: Die Gruppengrößen können variieren; nicht von festen Längen ausgehen. scanf mit /-Trennzeichen verwenden: scanf("%d-%d-%d-%d-%d", ...)

Schreibe ein Programm, das eine Telefonnummer im Format (xxx) xxx-xxxx einliest und als xxx.xxx.xxxx ausgibt:

Telefonnummer eingeben [(xxx) xxx-xxxx]: (404) 817-6900
Eingegeben: 404.817.6900

Schreibe ein Programm, das die Zahlen 1 bis 16 (in beliebiger Reihenfolge) einliest und als 4×4-Feld anzeigt, gefolgt von Zeilen-, Spalten- und Diagonalsummen:

Zahlen 1 bis 16 eingeben:
16 3 2 13 5 10 11 8 9 6 7 12 4 15 14 1

16  3  2 13
 5 10 11  8
 9  6  7 12
 4 15 14  1

Zeilensummen:     34 34 34 34
Spaltensummen:    34 34 34 34
Diagonalsummen:   34 34

Wenn alle Summen gleich sind, bilden die Zahlen ein magisches Quadrat.

Erweitere addfrac.c, sodass der Benutzer beide Brüche auf einmal eingibt, getrennt durch ein Pluszeichen:

Zwei Brüche mit Pluszeichen eingeben: 5/6+3/4
Die Summe ist 38/24

• Binäre Operatoren: +, -, *, /, %
• Unäre Operatoren: + (Vorzeichen plus), - (Vorzeichen minus)
• / bei Ganzzahlen: Ergebnis wird zur Null hin abgeschnitten (7/2 = 3, -7/2 = -3 in C99)
• % erfordert Integer-Operanden; Vorzeichen des Ergebnisses = Vorzeichen des Dividenden (C99)
• Gilt immer: (a/b) * b + a % b == a

Beispiel: UPC-Prüfziffer (upc.c)

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

• Einfache Zuweisung: v = e (speichert Wert von e in v; v muss ein lvalue sein)
• Zuweisung ist selbst ein Ausdruck → Ketten möglich: i = j = k = 0;
• Zusammengesetzte Operatoren: +=, -=, *=, /=, %=
  • v += e ist v = v + e, außer wenn v Nebeneffekte hat (dann v nur einmal ausgewertet)

• ++i (Präfix): erhöht i, gibt neuen Wert zurück
• i++ (Postfix): gibt alten Wert zurück, erhöht dann i
• --i / i--: analog für Dekrement

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

• Priorität und Assoziativität legen die Struktur fest (wo Klammern stehen würden)
• Die Reihenfolge der Teilauswertungen ist meist undefiniert (außer bei &&, ||, ?:, ,)
• Ausdrücke, die eine Variable gleichzeitig lesen und schreiben → undefiniertes Verhalten

/* SCHLECHT – undefiniertes Verhalten */
a = 5;
c = (b = a + 2) - (a = 1);   /* Ergebnis nicht vorhersagbar */

/* GUT – in getrennte Anweisungen aufteilen */
a = 5;  b = a + 2;  a = 1;  c = b - a;  /* c ist immer 6 */

• Jeder Ausdruck + ; = gültige Anweisung; sinnvoll nur mit Nebeneffekt

i = 1;       /* sinnvoll: Zuweisung            */
i--;         /* sinnvoll: Dekrement             */
i * j - 1;  /* sinnlos:  kein Nebeneffekt      */
i + j;       /* Tippfehler! gemeint war i = j;  */

• Kein **; für kleine Potenzen wiederholte Multiplikation (i * i * i = i³)
• Für nichtganzzahlige Potenzen: pow() aus <math.h>

• Nein, % erfordert Integer-Operanden
• Alternative: fmod() aus <math.h>

• C89: Ergebnis ist implementierungsabhängig (Compiler durfte runden oder abschneiden)
• C99: Division schneidet immer zur Null hin ab; dadurch gilt stets (a/b)*b + a%b == a
• Beispiel C89: -9/7 ist entweder -1 oder -2; in C99 ist es immer -1

• Ja: Ein lvalue ist ein Ausdruck, der links von = stehen kann (eine Speicherstelle)
• Ein rvalue ist ein Ausdruck auf der rechten Seite (Variable, Konstante oder komplexer Ausdruck)
• Der C-Standard verwendet stattdessen den Begriff “expression” statt “rvalue”

• v += e: v wird einmal ausgewertet
• v = v + e: v wird zweimal ausgewertet → Nebeneffekte verdoppeln sich
• Beispiel: a[i++] += 2; → i einmal erhöht; mit a[i++] = a[i++] + 2; wäre es undefiniertes Verhalten

• Von Ken Thompsons früherer Sprache B geerbt; B-Compiler konnte ++i kompakter übersetzen als i = i + 1
• Kein Geschwindigkeitsvorteil bei modernen Compilern; Beliebtheit beruht auf Kürze und Tradition

• Ja, aber in der Praxis selten sinnvoll

• Spätestens am Ende der Ausdrucksanweisung (Sequenzpunkt)
• Auch Funktionsaufrufe sind Sequenzpunkte: Argumente sind vollständig ausgewertet (inkl. ++~/–~) bevor die Funktion aufgerufen wird
• Innerhalb desselben Ausdrucks ist die genaue Reihenfolge undefiniert

• Ein Ausdruck hat immer einen Wert; wird er nicht gespeichert, geht er verloren
• i + 1; berechnet den Wert, speichert ihn aber nirgends → verloren

• = ist ein Operator und erzeugt wie jeder Operator einen Wert (hier: 1)
• Dieser Wert wird verworfen; das ist kein Problem, da der Zweck der Anweisung die Änderung von i war

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

• (a) i=5; j=3; printf("%d %d", i/j, i%j); → 1 2
• (b) i=2; j=3; printf("%d", (i+10)%j); → 0 (12%3=0)
• (c) i=7; j=8; k=9; printf("%d", (i+10)%k/j); → 1 (17%9=8, 8/8=1)
• (d) i=1; j=2; k=3; printf("%d", (i+5)%(j+2)/k); → 0 (6%4=2, 2/3=0)

Haben bei positiven Ganzzahlen i, j die Ausdrücke (-i)/j und -(i/j) immer denselben Wert?

• In C99: Ja. Division schneidet beide zur Null hin ab, Vorzeichen ist identisch.

Welche Werte haben folgende Ausdrücke in C89? (mehrere Werte möglich bei negativen Operanden)

• (a) 8/5 → 1
• (b) -8/5 → -1 oder -2
• (c) 8/-5 → -1 oder -2
• (d) -8/-5 → 1 oder 2

Wie Übung 3, aber in C99 (Division schneidet immer zur Null hin ab):

• (a) 8/5 → 1
• (b) -8/5 → -1
• (c) 8/-5 → -1
• (d) -8/-5 → 1

Welche Werte haben folgende Ausdrücke in C89? (mehrere Werte möglich)

• (a) 8%5 → 3
• (b) -8%5 → -3 oder 2
• (c) 8%-5 → 3 oder -2
• (d) -8%-5 → -3 oder 2

Wie Übung 5, aber in C99 (Vorzeichen des Rests = Vorzeichen des Dividenden):

• (a) 8%5 → 3
• (b) -8%5 → -3
• (c) 8%-5 → 3
• (d) -8%-5 → -3

Warum funktioniert die vereinfachte UPC-Variante nicht?

• Original: 9 - ((total - 1) % 10)
• Vereinfacht: berechne total % 10, subtrahiere von 10
• Problem: Wenn total % 10 == 0, ergibt 10 - 0 = 10 — keine gültige einstellige Prüfziffer
• Original erzeugt in diesem Fall korrekt 9 - 9 = 0

Würde upc.c noch funktionieren, wenn 9 - ((total-1) % 10) durch (10 - (total % 10)) % 10 ersetzt wird?

• Ja. Wenn total % 10 == 0: (10-0)%10 = 0 ✓; wenn total % 10 == t: (10-t)%10 = 10-t für t>0 ✓

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

• (a) i=7; j=8; i*=j+1; printf("%d %d", i, j); → 63 8
• (b) i=j=k=1; i+=j+=k; printf("%d %d %d", i, j, k); → 3 2 1
• (c) i=1; j=2; k=3; i-=j-=k; printf("%d %d %d", i, j, k); → 2 -1 3
• (d) i=2; j=1; k=0; i*=j*=k; printf("%d %d %d", i, j, k); → 0 0 0

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

• (a) i=6; j=i+=i; printf("%d %d", i, j); → 12 12
• (b) i=5; j=(i-=2)+1; printf("%d %d", i, j); → 3 4
• (c) i=7; j=6+(i=2.5); printf("%d %d", i, j); → 2 8 (2.5 abgeschnitten zu 2)
• (d) i=2; j=8; j=(i=6)+(j=3); printf("%d %d", i, j); → 6 9

Welche Ausgabe erzeugen folgende Fragmente? (i, j, k sind int; ★ = Auswertungsreihenfolge kann implementierungsabhängig sein)

• (a) i=1; printf("%d ", i++-1); printf("%d", i); → 0 2
• (b) i=10; j=5; printf("%d ", i++-++j); printf("%d %d", i, j); → 4 11 6
• (c) i=7; j=8; printf("%d ", i++---j); printf("%d %d", i, j); → 0 8 7
• (d) ★ i=3; j=4; k=5; printf("%d ", i++-j+++--k); printf("%d %d %d", i, j, k); → implementierungsabhängig (links→rechts: 3 4 5 4)

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

• (a) i=5; j=++i*3-2; printf("%d %d", i, j); → 6 16
• (b) i=5; j=3-2*i++; printf("%d %d", i, j); → 6 -7
• (c) i=7; j=3*i--+2; printf("%d %d", i, j); → 6 23
• (d) i=7; j=3+--i*2; printf("%d %d", i, j); → 6 15

Welcher der Ausdrücke ++i und i++ ist genau dasselbe wie (i += 1)?

• ++i — beide geben den neuen Wert von i zurück
• i++ gibt den alten Wert zurück → nicht äquivalent

Klammern setzen, um zu zeigen, wie der Compiler den Ausdruck liest:

• (a) a*b-c*d+e → ((a*b)-(c*d))+e
• (b) a/b%c/d → ((a/b)%c)/d
• (c) -a-b+c-+d → ((-a)-b)+(c-(+d))
• (d) a*-b/c-d → ((a*(-b))/c)-d

Werte von i und j nach jeder Anweisung? (i=1, j=2 zu Beginn)

• (a) i += j; → i=3, j=2
• (b) i--; → i=0, j=2
• (c) i * j / i; → i=1, j=2 (kein Nebeneffekt)
• (d) i % ++j; → i=1, j=3 (kein Nebeneffekt auf i)

Schreibe ein Programm, das eine zweistellige Zahl einliest und mit vertauschten Ziffern ausgibt:

Zweistellige Zahl eingeben: 28
Umgekehrt: 82

Hinweis: letzte Ziffer n%10, erste n/10; Ausgabe mit printf("%d%d\n", n%10, n/10)

Erweitere Projekt 1 für dreistellige Zahlen:

Dreistellige Zahl eingeben: 123
Umgekehrt: 321

Wie Projekt 2, aber ohne Arithmetik zum Zerlegen — stattdessen %1d in scanf verwenden (wie upc.c):

int d1, d2, d3;
scanf("%1d%1d%1d", &d1, &d2, &d3);
printf("%d%d%d\n", d3, d2, d1);

Schreibe ein Programm, das eine ganze Zahl (0–32767) einliest und in Oktal (Basis 8) ausgibt:

Zahl zwischen 0 und 32767 eingeben: 1953
In Oktal: 03641

Hinweis: letzte Oktalziffer n%8, dann n/8 wiederholen; printf kann auch %o für Oktal (Kapitel 7)

Erweitere upc.c, sodass der Benutzer alle 11 Ziffern auf einmal eingibt:

Erste 11 Stellen des UPC eingeben: 01380015173
Prüfziffer: 5

Hinweis: scanf("%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d%1d", &d, &i1, ...)

Schreibe ein Programm, das die EAN-Prüfziffer (European Article Number, 13 Stellen) berechnet. Algorithmus ähnlich wie UPC:

• Summe 1: gerade Positionen (2., 4., 6., 8., 10., 12.)
• Summe 2: ungerade Positionen (1., 3., 5., 7., 9., 11.)
• Gesamtsumme: Summe1 × 3 + Summe2; dann 9 - ((gesamt - 1) % 10)

Erste 12 Stellen der EAN eingeben: 869148426000
Prüfziffer: 8

Schreibe eine Funktion diffieHellman, die die Parameter p, g, a und b entgegennimmt und K1 und K2 berechnet.

Implementiere dasselbe Verfahren in Python.

• Primzahl: p = 23
• Basis: g = 5
• Alice privat: a = 6
• Bob privat: b = 15