Unterrichtsmaterial

Definiere eine Variable favorite-food mit deinem Lieblingsessen und gib sie aus. Binde sie dann mit set! an ein anderes Essen und gib sie erneut aus.

#lang racket
(define favorite-food "Pizza")
(displayln favorite-food)
(set! favorite-food "Sushi")
(displayln favorite-food)

Pizza
Sushi

Ja. Es gibt kebab-case, camelCase, snake_case und noch vieles mehr.

Schreibe zwei Testausdrücke: einen mit zero? und einen mit string=?, und gib beide mit displayln aus.

#lang racket
(displayln (zero? 0))
(displayln (string=? "racket" "racket"))

#t
#t

#lang racket
(define name "ada lovelace")
(displayln (string-titlecase name))
(displayln (string-upcase name))
(displayln (string-downcase name))

Ada Lovelace
ADA LOVELACE
ada lovelace

#lang racket
(define first-name "ada")
(define last-name "lovelace")
(define full-name (string-append first-name " " last-name))
(displayln (string-titlecase full-name))

;; formatierte Ausgabe mit printf
(printf "Hallo, ~a!~n" (string-titlecase full-name))

Ada Lovelace
Hallo, Ada Lovelace!

printf printed sachen schön, und man kan Variablen in String benutzen.

#lang racket
(define full-name "charles babbage")
(printf "Hi ~a!~n" (string-titlecase full-name))

~a ist Platzhalter für eine Variable. ~n heißt: neue Zeile!

#lang racket
(define favorite-language "\tRacket ")
(displayln favorite-language)
(displayln (string-trim favorite-language))

	Racket 
Racket

Ganzzahlen sind in Racket standardmäßig exakt und beliebig groß - kein Überlauf.

#lang racket
(displayln (+ 2 3))
(displayln (- 3 2))
(displayln (* 2 3))
(displayln (/ 3 2))       ; exakte rationale Zahl, nicht abgeschnitten!
(displayln (expt 3 2))
(displayln (modulo 3 2))
(displayln (modulo 4 2))

5
1
6
3/2
9
1
0

#lang racket
(displayln (+ 0.1 0.2))
(displayln (* 2 3.0))

0.30000000000000004
6.0

#lang racket
(define age 23)
(define message (string-append "Alles Gute zum " (number->string age) ". Geburtstag!"))
(displayln message)
;; oder mit printf
(printf "Alles Gute zum ~a. Geburtstag!\n" age)

Alles Gute zum 23. Geburtstag!
Alles Gute zum 23. Geburtstag!

Erstelle eine Liste hobbies mit drei deiner Hobbys und gib sie aus.

#lang racket
(define hobbies (list "gitarre" "programmieren" "schach"))
(displayln hobbies)

(gitarre programmieren schach)

Erstelle colors mit drei Farben. Binde colors2 mit (cons "gold" colors) an eine neue Liste. Gib beide Listen aus und überzeuge dich, dass colors unverändert ist.

#lang racket
(define colors (list "rot" "grün" "blau"))
(define colors2 (cons "gold" colors))
(displayln colors)
(displayln colors2)

(rot grün blau)
(gold rot grün blau)

Definiere teams mit vier Mannschaftsnamen. Gib das erste Element mit car und list-ref aus, sowie das dritte Element (Index 2). Gib danach das letzte Element mit last aus.

#lang racket
(define teams (list "adler" "löwen" "falken" "wölfe"))
(displayln (car teams))
(displayln (list-ref teams 2))
(displayln (string-titlecase (car teams)))
(displayln (last teams))

adler
falken
Adler
wölfe

Baue mit teams und list-ref den Satz “Mein Lieblingsteam sind die Adler.”

#lang racket
(define teams (list "adler" "löwen" "falken" "wölfe"))
(define message (string-append "Mein Lieblingsteam sind die "
                                (string-titlecase (list-ref teams 0))
                                "."))
(displayln message)

Mein Lieblingsteam sind die Adler.

cons fügt vorne an (schnell, die natürliche Richtung für eine verkettete Liste); append fügt am Ende an (langsamer, da die ganze Liste durchlaufen wird):

#lang racket
(define motorcycles (list "honda" "yamaha" "suzuki"))

;; am Ende anhängen -> neue Liste
(define motorcycles-plus-ducati (append motorcycles "ducati"))
(displayln motorcycles-plus-ducati)

;; vorne einfügen -> neue Liste
(define motorcycles-plus-kawa (cons "kawasaki" motorcycles))
(displayln motorcycles-plus-kawa)

;; das Original bleibt unverändert
(displayln motorcycles)

(honda yamaha suzuki . ducati) <- warum ist da ein Punkt...? Erst mal unwichtig!
(kawasaki honda yamaha suzuki)
(honda yamaha suzuki)

Eine Liste “Schritt für Schritt” mit wiederholtem append aufzubauen ist unnötig und langsam - meist schreibt man die Liste direkt hin, oder baut sie mit map bzw. for/list aus einer anderen Liste. Das kommt später!

#lang racket
(define motorcycles2 (list "honda" "yamaha" "suzuki"))
(displayln motorcycles2)

(honda yamaha suzuki)

remove löscht das erste passende Element, filter entfernt alle Treffer (bzw. behält alles, was eine Bedingung erfüllt):

#lang racket
(define motorcycles (list "honda" "yamaha" "suzuki"))
(displayln (remove "honda" motorcycles))
(displayln motorcycles)

;; alle Treffer entfernen (remove löscht nur den ersten)
(define more-motorcycles (list "honda" "yamaha" "honda" "suzuki"))
(displayln (filter (lambda (m) (not (string=? m "honda"))) more-motorcycles))

(yamaha suzuki)
(honda yamaha suzuki)
(yamaha suzuki)

Braucht man das entfernte Element noch (z. B. für eine Ausgabe), liest man es vorher mit car aus:

#lang racket
(define motorcycles (list "honda" "yamaha" "suzuki"))
(printf "Das entfernte Motorrad war: ~a\n" (car motorcycles))
(displayln (remove (car motorcycles) motorcycles))

Das entfernte Motorrad war: honda
(yamaha suzuki)

sort verändert die Liste nicht, sondern gibt eine neue, sortierte Liste zurück:

#lang racket
(define cars (list "bmw" "audi" "toyota" "subaru"))

(displayln (sort cars string<?))   ; aufsteigend
(displayln (sort cars string>?))   ; absteigend
(displayln cars)                    ; Original unverändert!

(audi bmw subaru toyota)
(toyota subaru bmw audi)
(bmw audi toyota subaru)

#lang racket
(define cars (list "bmw" "audi" "toyota" "subaru"))
(displayln (reverse cars))
(displayln cars)

(subaru toyota audi bmw)
(bmw audi toyota subaru)

#lang racket
(sum)
(define cars (list "bmw" "audi" "toyota" "subaru"))
(displayln (length cars))

4

Definiere bands mit drei Bandnamen. Gib mit for-each für jede Band “\~a rockt!” aus.

#lang racket
(define bands (list "queen" "acdc" "rush"))
(for ((band bands))(printf "~a rockt!\n" (string-titlecase band)))

Queen rockt!
Acdc rockt!
Rush rockt!

range erzeugt eine Liste von Zahlen; der Endpunkt ist exklusiv, eine Schrittweite ist optional:

#lang racket
(displayln (range 1 5))
(for ((value (range 1 5))) (displayln value))
(displayln (range 1 11 2))

(1 2 3 4)
1
2
3
4
(1 3 5 7 9)

#lang racket
(define numbers (range 1 11))
(printf "min: ~a\n" (apply min numbers)) ; warum apply? Apply wendet 'min' auf alle Elemente in numbers.
(printf "max: ~a\n" (apply max numbers))
(printf "summe (mit apply): ~a\n" (apply + numbers)) ; und was passiert hier?
(printf "summe (mit for/sum): ~a\n" (for/sum ((n numbers)) n)) ; und hier?

min: 1
max: 10
summe (mit apply): 55
summe (mit for/sum): 55

Beide bauen eine neue Liste aus einer Berechnung - for/list ist eine Art List Comprehension, map wendet eine Funktion direkt auf jedes Element an. Für einfache Fälle sind sie austauschbar:

#lang racket
(define squares (for/list ((value (in-range 1 11))) (sqr value)))
(define squares2 (map sqr (range 1 11)))
(displayln squares)
(displayln squares2)

(1 4 9 16 25 36 49 64 81 100)
(1 4 9 16 25 36 49 64 81 100)

take liefert die ersten n Elemente, drop überspringt die ersten n:

#lang racket
(define players (list "charles" "martina" "michael" "florence" "eli"))

(displayln (take players 3))          ; die ersten drei
(displayln (drop players 1))          ; alle außer dem ersten
(displayln (take (drop players 1) 3)) ; Elemente 2 bis 4

(charles martina michael)
(martina michael florence eli)
(martina michael florence)

• Lisp läuft interaktiv über ein Toplevel in REPL (Read Evaluate Print Loop): man tippt einen Ausdruck ein, bekommt sofort den Wert zurück, dann kommt der nächste Prompt (>).
• Selbstauswertende Atome: eine Zahl wie 1 ergibt einfach 1, und ein Atom wie 'a ergibt 'a.
• Funktionsaufrufe in Präfixnotation: Operator zuerst, dann die Argumente, alles in Klammern. (+ 2 3) statt 2 + 3.
• Das ist komisch, und macht Lisp ganz anderes, aber ist eins der besten Features.

• Weil die Klammern den Ausdruck begrenzen und nicht die Anzahl der Argumente, kann ein Operator beliebig viele Argumente nehmen, auch keine:

  (+)          ;; => 0
  (+ 2)        ;; => 2
  (+ 2 3 4 5)  ;; => 14
  

• Ausdrücke lassen sich beliebig verschachteln, Argumente können selbst wieder Ausdrücke sein:

  (/ (- 7 1) (- 4 2))  ;; => 3
  

• In Lisp ist alles entweder ein Atom oder eine Liste. Eine einzige Syntax für alles, im Gegensatz zu C, wo Arithmetik, Aufrufe, Anweisungen und Blöcke jeweils eigene Syntax haben.

• Das heisst, dass Lisp kaum Syntax hat, und wir können uns ziemlich schnell mit Informatik (anstatt die Sprache) beschäftigen.

  Beispiel:

  Program	Python	Lisp
  addiere zwei Zahlen	2 + 3	(+ 2 3)
  Printe “Hallo”	print("Hallo")	(print "hallo")
  Schreibe “abc” gross	"a b c".upper()	(string-upcase "a b c")
  Gebe den grösseren Wert zurück	if (a > b): return a else: return b	(if (> a b) a b)
  Definiere eine Addition-Funktion	def adder(a, b): return (a + b)	(defun adder (a b) (+ a b))
  Eine Schlüsselwertpaarsammlung	{key:value, key2:value2}	((key value) (key value))

• Ja, Lisp sieht doch einfacher aus, trotz der ganzen Klammern, weil die Syntax immer gleich bleibt. Alles ist eine Liste oder ein Atom. Listen werden evaluiert. Cool!

WICHTIG

• Auswertungsregel für Funktionsaufrufe: erst alle Argumente von links nach rechts auswerten, dann die Werte an die Funktion des Operators übergeben.
• Verschachtelte Aufrufe werden nach der gleichen Regel von innen nach außen ausgewertet.

• quote ist die Ausnahme, ein Special Operator mit eigener Regel: gib das Argument einfach unverändert zurück. 'x ist Kurzform für (quote x).

  (quote (+ 3 5))  ;; =>   (+ 3 5) und nicht 8
  '(+ 3 5)         ;; =>   (+ 3 5), gleiche Sache
  (cons 'a '(b c)) ;; =>   '(a b c)
  '(cons 'a '(b c)) ;; =>  '(cons 'a '(b c))
  

• Quoten schützt Daten davor, als Code gelesen zu werden.
• I.d.R. werden alle Listen als Formen interpretiert, also das erste Element wird als Funktion interpretiert, und alle andere Elemente als Argumente. ' verhindert das.

• Man landet in einem Break Loop, quasi ein Error-REPL innerhalb des Toplevels.
• Rauskommen je nach Implementierung, meistens mit der Taste q, oder einem Abort-Restart (:abort in SBCL bzw. den meisten CL-REPLs oder C-c C-c und Restart-Auswahl in SLIME).

• Weil man sie gar nicht zählen soll, man liest und schreibt Lisp nach Einrückung, das Zuordnen der Klammern übernimmt der Editor (Paren-Matching, structural editing).

• Common Lisp nutzt Manifest Typing: Werte tragen Typen, Variablen nicht. Jede Variable kann jeden Typ aufnehmen, keine Deklaration nötig (optional möglich, wegen Performance, siehe Kapitel 13).
• Typen bilden eine Hierarchie, ein Objekt hat gleichzeitig mehrere Typen, vom speziellsten zum allgemeinsten (z.B. ist 27 gleichzeitig fixnum, integer, rational, real, number, atom, t).
• t ist der Supertyp von allem.
• typep prüft Typzugehörigkeit: (typep 27 'integer) => T.

• eine positive Zahl nimmt und entsprechend viele Punkte ausgibt
• eine Liste nimmt und zählt, wie oft das Symbol a darin vorkommt

• 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