# 1.3 Bedingte Anweisungen

Quelle: https://inf.zone/lectures/1-c/short-1-3-bedingungen/

## Video

[Video ansehen](https://oc.streams.uni-bamberg.de/paella7/ui/watch.html?id=a19bc49e-5f79-4b48-a5c9-92e86b2b49fd)

### Alternativen

- [Video auf YouTube](https://youtu.be/PGilCiIz16c)
- Download (1080p) (demnächst)
- Download (720p) (demnächst)
- Download (540p) (demnächst)

## Hinweise zu diesem Video

**Korrekturen**

Die Korrekturen betreffen das Video. In den Folien zum Herunterladen sind sie eingearbeitet, soweit sie die Folien betreffen.

- Folie 13, Frage F3: Gemeint ist der ternäre bedingte Operator (? :) von Folie 10, kein Vergleichsoperator.

## Material

- [Folien](https://inf.zone/download/lectures/1-c/1.3-bedingungen.pdf)
- Folien und Transkript: unten auf dieser Seite

## Folien und Transkript

*Folientext aus den PDF-Folien, darunter jeweils der gesprochene Text des Videos. Der gesprochene Text ist maschinell transkribiert und nachkorrigiert, kann aber noch Fehler enthalten; im Video sprechen abwechselnd Prof und eine AI-Figur, die Sprecherwechsel sind nicht markiert. Die Zuordnung zu den Folien ist ungefähr. Die Zeitangaben verlinken auf die Stelle im Video (YouTube). Maßgeblich sind Video und Folien.*

### Folie 1 — Bedingte Anweisungen

[Folie 1 als PDF](https://inf.zone/download/lectures/1-c/1.3-bedingungen.pdf#page=1)

#### Transkript

> Zuordnung unsicher: wenige gemeinsame Textmerkmale; anhand der benachbarten Folien eingeordnet.

**[Video 00:00–00:31](https://www.youtube.com/watch?v=PGilCiIz16c&t=0)**

Dies ist Inf-Einf-B.

### Folie 2

[Folie 2 als PDF](https://inf.zone/download/lectures/1-c/1.3-bedingungen.pdf#page=2)

Bedingte Anweisungen ermöglichen es Programmen, Entscheidungen zu treffen und sich je nach Wert von Variablen oder Benutzereingaben unterschiedlich zu verhalten. Man nennt diese auch Verzweigungen (Englisch: forks oder branches).

#### Transkript

**[Video 00:00–00:31](https://www.youtube.com/watch?v=PGilCiIz16c&t=0)**

Heute bedingte Anweisungen. Bedingte Anweisungen ermöglichen es Ihren Programmen, Entscheidungen zu treffen und sich je nach Wert von Variablen oder Benutzereingaben unterschiedlich zu verhalten. Man nennt diese auch Verzweigungen oder auf Englisch Forks.

### Folie 3

[Folie 3 als PDF](https://inf.zone/download/lectures/1-c/1.3-bedingungen.pdf#page=3)

Wir sehen uns die verschiedenen Varianten an, mit denen man in C solche bedingten Anweisungen implementieren kann.

Einige davon kommen Ihnen vielleicht aus Scratch bekannt vor.

#### Transkript

**[Video 00:00–00:31](https://www.youtube.com/watch?v=PGilCiIz16c&t=0)**

Wir sehen uns die verschiedenen Varianten an, mit denen man in C solche bedingten Anweisungen implementieren kann. Einige davon kommen Ihnen vielleicht aus Scratch bekannt vor. Nanu, hast du heute gar nichts an meiner Einführung auszusetzen?

**[Video 00:31–00:59](https://www.youtube.com/watch?v=PGilCiIz16c&t=31)**

Passt schon so. Mach einfach weiter. Sehr gut. Na dann kann's ja losgehen.

### Folie 4 — if-Anweisung

[Folie 4 als PDF](https://inf.zone/download/lectures/1-c/1.3-bedingungen.pdf#page=4)

```text
if (boolescher Ausdruck)
{
    // einige Anweisungen
}
```

Wenn der boolesche Ausdruck wahr ist, werden alle Codezeilen zwischen den geschweiften Klammern `{ … }` in der Reihenfolge von oben nach unten ausgeführt.

Wird der boolesche Ausdruck als falsch ausgewertet, werden diese Zeilen nicht ausgeführt.

> Bildinhalte sind nicht transkribiert; siehe Originalfolie.

#### Transkript

**[Video 00:31–00:59](https://www.youtube.com/watch?v=PGilCiIz16c&t=31)**

Beginnen wir mit der if-Anweisung. Die Syntax sieht so aus: if, dann in Klammern ein boolscher Ausdruck, dann eine geschweifte Klammer auf, dann einige Codezeilen und eine geschweifte Klammer zu. In C dienen die geschweiften Klammern einem ähnlichen Zweck wie die C-förmigen Blöcke in Scratch. Sie kapseln den Code, der ausgeführt werden soll, wenn die Bedingung erfüllt ist.

**[Video 00:59–01:28](https://www.youtube.com/watch?v=PGilCiIz16c&t=59)**

Wenn der boolsche Ausdruck als wahr ausgewertet wird, werden alle Codezeilen zwischen den geschweiften Klammern in der Reihenfolge von oben nach unten ausgeführt. Wenn der boolsche Ausdruck als falsch ausgewertet wird, werden diese Codezeilen nicht ausgeführt. Danach läuft das Programm mit dem Code weiter, der nach dem Block mit den geschweiften Klammern kommt. Mhm. Vielleicht gleich noch hier einen Hinweis an der Stelle: C erlaubt grundsätzlich auch eine Abkürzung, und die wird in der Praxis auch recht häufig verwendet. Wenn der Codeblock, der von der if-Anweisung umschlossen wird,

**[Video 01:28–01:55](https://www.youtube.com/watch?v=PGilCiIz16c&t=88)**

nur aus einer einzigen Anweisung besteht, dann kann man die geschweiften Klammern auch weglassen. Aus Gründen der Übersichtlichkeit und vor allem zur Vermeidung von Fehlern empfehlen wir aber tatsächlich bei jeder if-Anweisung geschweifte Klammern zu verwenden, selbst dann, wenn sie nur eine einzige Codezeile umschließt. Und noch ein Hinweis: Die geschweiften Klammern erreichen Sie auf einer deutschen Tastatur unter Windows wieder mit der Taste Alt Gr. Die Klammern erreicht man über die Ziffer 7

**[Video 01:55–02:29](https://www.youtube.com/watch?v=PGilCiIz16c&t=115)**

und die Ziffer Null. Auf dem Mac erreicht man sie mit Alt acht und Alt neun. Als nächstes sehen wir uns die if-else-Anweisung an. Hier gibt es zwei Codeblöcke in geschweiften Klammern. Der erste Block wird wieder nur dann ausgeführt, wenn der boolsche Ausdruck wahr ist.

### Folie 5 — if-elseAnweisung

[Folie 5 als PDF](https://inf.zone/download/lectures/1-c/1.3-bedingungen.pdf#page=5)

```text
if (boolescher Ausdruck)
{
    // einige Anweisungen
}
else
{
    // weitere Anweisungen
}
```

Ergibt der boolesche Ausdruck „wahr“, werden alle Codezeilen nach dem „if“ ausgeführt. Ist der boolesche Ausdruck „falsch“, werden alle Codezeilen nach dem „else“ ausgeführt.

> Bildinhalte sind nicht transkribiert; siehe Originalfolie.

#### Transkript

**[Video 01:55–02:29](https://www.youtube.com/watch?v=PGilCiIz16c&t=115)**

Nun gibt es aber einen zweiten Block nach dem else. Dieser wird ausgeführt, falls der boolsche Ausdruck falsch ist. Es wird also in jedem Fall einer der beiden Blöcke ausgeführt, aber auf keinen Fall beide.

### Folie 6

[Folie 6 als PDF](https://inf.zone/download/lectures/1-c/1.3-bedingungen.pdf#page=6)

else if Ermöglicht es, mehrere Bedingungen von oben nach unten zu überprüfen. Wird dabei eine Bedingung erreicht, die wahr ist, wird der dazugehörige Codeblock ausgeführt, alle anderen werden übersprungen.

```text
if (boolean-expr1)
{
    // erster Block
}
else if (boolean-expr2)
{
    // zweiter Block
}
else if (boolean-expr3)
{
    // dritter Block
}
else
{
    // vierter Block
}
```

Das „else“ am Ende ist optional, ist aber sehr empfehlenswert, um keine Fälle zu vergessen.

#### Transkript

**[Video 01:55–02:29](https://www.youtube.com/watch?v=PGilCiIz16c&t=115)**

Danach läuft das Programm mit dem Code weiter, der nach der letzten schließenden geschweiften Klammer steht. Weiter geht es mit else if

**[Video 02:29–02:57](https://www.youtube.com/watch?v=PGilCiIz16c&t=149)**

Die if-Anweisung kann nicht nur mit einem else-Zweig erweitert werden, sondern auch mit einem else-if-Zweig. In Scratch erforderte die Erstellung dieser Art von Struktur Verschachtelungsblöcke, was sehr kompliziert werden konnte. In C können wir dies als einfache Kette von Anweisungen schreiben. Mit else-if ist es möglich, mehrere Bedingungen von oben nach unten zu überprüfen. Sobald dabei eine Bedingung erreicht wird, die wahr ist, wird der dazugehörige Codeblock ausgeführt.

**[Video 02:57–03:31](https://www.youtube.com/watch?v=PGilCiIz16c&t=177)**

Der else-Zweig, ganz am Ende, ist optional, ist aber sehr empfehlenswert, um keine Fälle zu vergessen. Er wird ausgeführt, wenn keine der vorherigen Bedingungen erfüllt war. Da würde ich gerne noch etwas ergänzen: Die booleschen Ausdrücke, und übrigens spricht man die so aus, nicht boolsche Ausdrücke, wie du immer sagst, müssen sich nicht unbedingt gegenseitig ausschließen. Es wird aber immer nur der Codeblock ausgeführt, der hinter der ersten passenden Bedingung steht. Alle späteren else-if-Zweige werden dann übersprungen, selbst wenn die Bedingungen, die dort stehen, ebenfalls erfüllt werden.

### Folie 7

[Folie 7 als PDF](https://inf.zone/download/lectures/1-c/1.3-bedingungen.pdf#page=7)

Mehrere ifAnweisungen Es ist auch möglich, eine Kette von Zweigen zu erstellen, die sich nicht gegenseitig ausschließen.

```text
if (boolean-expr1)
{
    // erster Block
}
if (boolean-expr2)
{
    // zweiter Block
}
if (boolean-expr3)
{
    // dritter Block
}
else
{
    // vierter Block
}
```

In diesem Beispiel schließen sich nur der dritte und vierte Zweig gegenseitig aus. Das „else“ gehört immer zum unmittelbar vorherigen „if“-Block.

#### Transkript

**[Video 02:57–03:31](https://www.youtube.com/watch?v=PGilCiIz16c&t=177)**

Stimmt, guter Hinweis.

**[Video 03:31–04:05](https://www.youtube.com/watch?v=PGilCiIz16c&t=211)**

Schreibt man statt else if einfach if, kann man eine Kette von Zweigen erstellen, die sich nicht gegenseitig ausschließen. In diesem Beispiel schließen sich nur der dritte und vierte Zweig gegenseitig aus. Das else gehört immer zum unmittelbar vorherigen if-Block. Es wäre auch möglich, bei einigen Zweigen zusätzlich einen else-if-Zweig einzubauen. Dann wird es schnell kompliziert und man sollte durch Kommentare oder extra Abstand zwischen den Blöcken, die zusammengehören, klarmachen, was die Intention ist. Ja klar, Kommentare einfügen ist sowieso eine gute Idee. Später erinnert man sich nämlich vielleicht überhaupt nicht mehr daran.

**[Video 04:05–04:34](https://www.youtube.com/watch?v=PGilCiIz16c&t=245)**

Was man mit einem bestimmten Code, den man geschrieben hat, bezwecken wollte, da kann so ein erläuternder Kommentar echt sehr hilfreich sein. Am besten schreibt man dorthin, was man sich dabei gedacht hat oder was man dabei erwartet, als dieser Code laufen sollte. Was man damit bezwecken will. Was wenig Sinn macht, ist dorthin zu schreiben, zum Beispiel hinter ein if x größer fünf, dass x größer fünf ist, soll geprüft werden. Das sagt der Code ja schon selber. Daher noch einmal die Warnung.

**[Video 04:34–05:08](https://www.youtube.com/watch?v=PGilCiIz16c&t=274)**

Bei direkt aufeinanderfolgenden if-Anweisungen muss man wirklich aufpassen, weil es schnell unübersichtlich wird und dann nicht mehr klar ist, welche Blöcke ausgeführt werden oder werden sollen.

### Folie 8

[Folie 8 als PDF](https://inf.zone/download/lectures/1-c/1.3-bedingungen.pdf#page=8)

switchAnweisung Die switch-Anweisung ermöglicht eine Aufzählung einzelner Fälle, anstatt boolesche Ausdrücke zu verwenden.

```text
int x = get_int("");
switch(x)
{
case 1:
    printf("One!\n");
    break;
case 2:
    printf("Two!\n");
    break;
case 3:
    printf("Three!\n");
    break;
default:
    printf("Sorry!\n");
}
```

Es ist wichtig, zwischen den einzelnen Fällen ein „break“ zu setzen, sonst „fällt man durch“ jeden Fall (es sei denn, das ist das gewünschte Verhalten).

#### Transkript

> Zuordnung unsicher: wenige gemeinsame Textmerkmale; anhand der benachbarten Folien eingeordnet.

**[Video 04:34–05:08](https://www.youtube.com/watch?v=PGilCiIz16c&t=274)**

Das kann zu unerwartetem Verhalten führen und Fehlern, die man nicht so leicht sieht.

### Folie 9

[Folie 9 als PDF](https://inf.zone/download/lectures/1-c/1.3-bedingungen.pdf#page=9)

Die switch-Anweisung ermöglicht eine Aufzählung einzelner Fälle, anstatt boolesche Ausdrücke zu verwenden.

switchAnweisung

```text
int x = get_int("");
switch(x)
{
case 4:
    printf("Vier!\n");
case 3:
    printf("Drei!\n");
case 2:
    printf("Zwei!\n");
case 1:
    printf("Eins!\n");
default:
    printf("Fertig!\n");
}
```

Es ist wichtig, zwischen den einzelnen Fällen ein „break“ zu setzen, sonst „fällt man durch“ jeden Fall (es sei denn, das ist das gewünschte Verhalten).

#### Transkript

**[Video 04:34–05:08](https://www.youtube.com/watch?v=PGilCiIz16c&t=274)**

Die switch-Anweisung ermöglicht eine Aufzählung einzelner Fälle, anstatt boolesche Ausdrücke zu verwenden. Hinter dem case steht jeweils einer der möglichen Werte der Variablen, auf die sich die switch-Anweisung bezieht. Moment, du hast vergessen, get_int zu erklären. Das hätte ich halt am Schluss gemacht.

**[Video 05:08–05:42](https://www.youtube.com/watch?v=PGilCiIz16c&t=308)**

Aber dann halt gleich. Die in diesem Beispiel verwendete Funktion get_int ist Teil der CS50-Bibliothek. Die Funktion fordert den Benutzer auf, mit der Tastatur einen Integer-Wert einzugeben. Die eingegebene Zahl wird in diesem Beispiel dann der Variablen x zugewiesen. Damit man get_int verwenden kann, muss man die Header-Datei cs50.h einbinden. Jetzt aber weiter. Die break-Anweisung führt dazu, dass alle weiteren Zweige übersprungen werden. Es ist wichtig, zwischen den einzelnen Fällen ein break zu setzen, sonst fällt man in den darauf folgenden Fall. Das ist meistens nicht beabsichtigt.

**[Video 05:42–06:15](https://www.youtube.com/watch?v=PGilCiIz16c&t=342)**

So und dann fehlt uns noch default. Der Code bei default wird ausgeführt, wenn keiner der anderen Fälle zutraf. Ganz genau. Die switch-Anweisung, das ist ein ganz neues Konzept. Das haben wir in Scratch in der Form noch gar nicht gesehen und das gibt es da auch nicht. Die ist insbesondere dann nützlich, wenn man eben eine Variable hat, die mehrere verschiedene, man sagt auch diskrete Werte annehmen kann. So, hier sieht man noch einmal, was ohne break-Anweisung passiert. Die Ausführung wird dann direkt nach dem nächsten case fortgesetzt, ohne noch einmal den Inhalt der Variable zu prüfen.

**[Video 06:15–06:45](https://www.youtube.com/watch?v=PGilCiIz16c&t=375)**

Dieses Verhalten kann für bestimmte Abläufe absichtlich genutzt werden, etwa bei dem Countdown in diesem Beispiel. Hier werden dann absteigend alle Zahlen ausgegeben, beginnend mit der Zahl, die in x steht. Auch wenn dieses Durchfallen manchmal nützlich sein kann, muss man dabei gut aufpassen. Am besten gewöhnt man sich an, gleich das break zu schreiben, wenn man die Zeile mit case geschrieben hat. Das versehentliche Durchfallen aufgrund vergessener break-Anweisungen ist eine häufige Fehlerquelle, die man schnell übersieht.

### Folie 10 — Bedingter

[Folie 10 als PDF](https://inf.zone/download/lectures/1-c/1.3-bedingungen.pdf#page=10)

```text
int x;
if (expr)
{
   x =  5;
}
else
{
   x =  6;
}
```

Operator Syntax allgemein:

```text
(boolean-expr) ? value_if_true : value_if_false
```

lässt sich mit dem ternären bedingten Operator (`? :`) abkürzen:

```text
int x = (expr) ? 5 : 6;
```

#### Transkript

**[Video 06:15–06:45](https://www.youtube.com/watch?v=PGilCiIz16c&t=375)**

Nun kommen wir zum bedingten Operator.

**[Video 06:45–07:14](https://www.youtube.com/watch?v=PGilCiIz16c&t=405)**

Es gibt eine Kurzform, um einer Variable unterschiedliche Werte basierend auf einer Bedingung zuzuweisen. Das ist der sogenannte ternäre bedingte Operator, der aus einem Fragezeichen und einem Doppelpunkt besteht. Das ternär bedeutet, dass der Operator drei Operanden hat, im Unterschied zu binären Operatoren, etwa dem Plus. Diese haben zwei Operanden. Es gibt auch unäre Operatoren, etwa Plus Plus zum Inkrementieren, die nur einen Operanden haben. Aber zurück zum bedingten Operator. Damit kann man sehr kompakten Code schreiben.

### Folie 11 — Guter Stil

[Folie 11 als PDF](https://inf.zone/download/lectures/1-c/1.3-bedingungen.pdf#page=11)

Ein guter Stil verbessert die Lesbarkeit und Wartbarkeit. Guter Stil bei bedingten Anweisungen:

```text
if (x < 0)
{
    printf("negativ\n");
}
else
{
    printf("mindestens 0\n");
}
```

geschweifte Klammern auf eigenen

Zeilen, richtig ausgerichtet;

je ein Leerzeichen nach „if“, „else if“

und „else“;

einheitliche Einrückung (4 Leerzeichen);

ein Leerzeichen um Operatoren (\>, ==, …);

keine Leerzeichen unmittelbar nach

öffnenden Klammern oder vor schließenden Klammern und

öffnende geschweifte Klammer nicht in

derselben Zeile wie Bedingung.

#### Transkript

**[Video 07:14–07:49](https://www.youtube.com/watch?v=PGilCiIz16c&t=434)**

Bei übermäßigem Gebrauch leidet darunter aber die Lesbarkeit. Es ist gut, damit vertraut zu sein, da man ihm im Code anderer Leute begegnen wird. Aber man sollte sich nicht verpflichtet fühlen, ihn in eigenen Programmen zu verwenden, wenn man sich damit nicht wohl fühlt. Wunderbar. Jetzt wäre übrigens auch eine gute Gelegenheit, auf guten Stil hinzuweisen. Stell uns doch mal ein paar Hinweise zusammen. Ein guter Stil verbessert die Lesbarkeit und Wartbarkeit von Code. Hier sind ein paar Eigenschaften guten Stils bei bedingten Anweisungen. Die geschweiften Klammern stehen auf eigenen Zeilen und sind richtig ausgerichtet. Es kommt immer genau ein Leerzeichen nach if

**[Video 07:49–08:20](https://www.youtube.com/watch?v=PGilCiIz16c&t=469)**

else if und else. Codeblöcke sind einheitlich eingerückt, am besten um vier Leerzeichen, damit schnell erkennbar ist, was zusammengehört. Es kommt immer genau ein Leerzeichen vor und nach Operatoren wie größer als und gleich gleich. Aber es stehen keine Leerzeichen unmittelbar nach öffnenden Klammern oder vor schließenden Klammern. Und die öffnende geschweifte Klammer steht nicht in derselben Zeile wie die Bedingung, sondern in einer eigenen Zeile. Während wir in den vorherigen Videos nicht so viel Wert auf guten Stil gelegt haben, wird dieser immer wichtiger,

**[Video 08:20–08:51](https://www.youtube.com/watch?v=PGilCiIz16c&t=500)**

je komplexer unsere Programme werden. Ein guter Stil erleichtert das Lesen, Debuggen und Pflegen Ihres Codes. Denken Sie daran, dass der Code, den Sie schreiben, nicht nur für den Computer ist, sondern auch für andere Menschen lesbar sein muss und auch für Ihr zukünftiges Ich. Die sollen ihn auch lesen und verstehen können. Ein klarer und konsistenter Stil ist nicht nur eine Höflichkeit gegenüber Ihren Mitmenschen, auch Ihr zukünftiges Ich wird es Ihnen danken, wenn Sie sich da mehr Mühe geben.

### Folie 12

[Folie 12 als PDF](https://inf.zone/download/lectures/1-c/1.3-bedingungen.pdf#page=12)

E X T R A S I N 3 M I N U T E N FRAGEN – ANTWORTEN – RÄTSEL UND KURZE ZUSAMMENFASSUNG

#### Transkript

**[Video 08:20–08:51](https://www.youtube.com/watch?v=PGilCiIz16c&t=500)**

So, was kommt als nächstes? Die drei Extraminuten? Ja.

**[Video 08:51–09:20](https://www.youtube.com/watch?v=PGilCiIz16c&t=531)**

Genau. Ich bin gespannt, was du dir heute ausgedacht hast. In Ordnung. Hier sind ein paar Fragen. Wunderbar. Die sind ja alle recht einfach. Da würde ich heute jetzt nicht näher drauf eingehen. Okay, dann schauen wir uns mal ein Programm an. Was wird hier ausgegeben? Ich glaube, dieses Programm müssen wir uns auch nicht im Detail anschauen. Die Studierenden können es ja selber ausführen, um zu prüfen, ob sie die richtige Lösung rausbekommen.

**[Video 09:20–09:51](https://www.youtube.com/watch?v=PGilCiIz16c&t=560)**

Ich habe auch etwas vorbereitet. Schau mal. Geh doch mal das folgende Programm für uns durch.

### Folie 13

[Folie 13 als PDF](https://inf.zone/download/lectures/1-c/1.3-bedingungen.pdf#page=13)

Was sind die drei Arten von bedingten Anweisungen, die besprochen wurden? F1:

Was ist der Zweck des „default“-Falls in einer switch-Anweisung? F2:

F3:

Schreiben Sie die folgende Anweisung so um, dass der ternäre bedingte Operator verwendet wird:

```text
if (x > 10) { y = 20; } else { y = 5; }
```

#### Transkript

*Kein Transkriptabschnitt eindeutig dieser Folie zugeordnet. Möglicherweise eine Aufbau-/Grafikfolie oder eine Abweichung zwischen PDF und Video.*

### Folie 14

[Folie 14 als PDF](https://inf.zone/download/lectures/1-c/1.3-bedingungen.pdf#page=14)

```text
int benutzerAlter = 17;
int postAlter = 48;  // in Stunden
int istPrivat = 0;   // 0 für nein, 1 für ja
int enthaeltHashtag = 1;  // 0 für nein, 1 für ja
int anzahlInteraktionen = 75;

if (!istPrivat && (benutzerAlter >= 18 || postAlter < 24))
{
    if (enthaeltHashtag && anzahlInteraktionen > 100)
    {
        printf("Trending");
    }
    else if (anzahlInteraktionen > 50 || (enthaeltHashtag && postAlter < 12))
    {
        printf("Erhöhte Sichtbarkeit");
    }
    else
    {
        printf("Normale Sichtbarkeit");
    }
}
else
{
    printf("Eingeschränkte Sichtbarkeit");
}
```

#### Transkript

*Kein Transkriptabschnitt eindeutig dieser Folie zugeordnet. Möglicherweise eine Aufbau-/Grafikfolie oder eine Abweichung zwischen PDF und Video.*

### Folie 15

[Folie 15 als PDF](https://inf.zone/download/lectures/1-c/1.3-bedingungen.pdf#page=15)

```text
int currentPlayer = 1;     // Spielernummer: 1 oder 2
int consecutiveSixes = 0;  // vorheriger Wurf war keine 6
int roll = 4;              // aktueller Würfelwurf

printf("Player %d rolled a %d.\n", currentPlayer, roll);

if (roll == 6)
{
    consecutiveSixes++;
    
    if (consecutiveSixes >= 3)
    {
        printf("Player %d wins!\n", currentPlayer);
    }
}
else
{
    consecutiveSixes = 0; // Zähler zurücksetzen
    currentPlayer = (currentPlayer == 1) ? 2 : 1;
    printf("It's now Player %d's turn.\n", currentPlayer);
}
```

#### Transkript

**[Video 09:20–09:51](https://www.youtube.com/watch?v=PGilCiIz16c&t=560)**

Okay, einen Moment. Zusammengefasst simuliert das Programm ein einfaches rundenbasiertes Würfelspiel, bei dem die Spieler abwechselnd würfeln. Wenn ein Spieler eine Sechs würfelt, erhöht er die Anzahl seiner aufeinanderfolgenden Sechsen und er ist noch einmal dran. Wenn man dreimal hintereinander die Sechs würfelt, hat man das Spiel gewonnen. Wenn man keine Sechs würfelt, setzt das Programm die Anzahl der aufeinanderfolgenden Sechsen zurück.

**[Video 09:51–10:25](https://www.youtube.com/watch?v=PGilCiIz16c&t=591)**

Dann ist der andere Spieler am Zug. Sehr gut. Ich denke, das sollte gut nachvollziehbar sein. Jetzt ändern wir die Spiellogik ein bisschen und machen es etwas komplizierter. Erklär uns doch mal, was nun passiert. Puh, wer hat das denn programmiert? Ich musste halt bisschen Platz sparen auf der Folie. Daher habe ich alle geschweiften Klammern weggelassen, die es nicht braucht, und den Code kompakt formatiert. Sonst wäre die Schrift ja noch kleiner geworden und es wäre schlecht zu lesen gewesen. Ganz ehrlich, eine kleinere Schrift wäre nicht so schlimm gewesen wie dieses Codeknäuel. Selbst ich tue mich damit schwer.

**[Video 10:25–10:51](https://www.youtube.com/watch?v=PGilCiIz16c&t=625)**

Naja, nicht wirklich. Aber egal. Also folgendes. Ah, Moment. Jetzt wäre eine gute Gelegenheit, das Video anzuhalten und selber darüber nachzudenken, bevor ich weitermache. Also, das Grundprinzip des Spiels ist das gleiche. Die Spieler würfeln weiterhin abwechselnd, und eine Sechs ermöglicht einen weiteren Wurf. Allerdings gibt es nun auch eine Punktesumme für jeden Spieler, und man gewinnt nicht mehr automatisch bei drei Sechsen in Folge.

**[Video 10:51–11:19](https://www.youtube.com/watch?v=PGilCiIz16c&t=651)**

Schauen wir uns zuerst den Fall an, dass die 6 gewürfelt wird. Wie zuvor erhöht sich dann der Zähler für aufeinanderfolgende Sechsen. Bei drei Sechsen in Folge wird eine Meldung ausgegeben und der Gewinner ermittelt. Der Spieler mit der höheren Punktesumme gewinnt das Spiel. Nun zum Fall, dass eine andere Zahl gewürfelt wurde. Zuerst wird der Zähler für aufeinanderfolgende Sechsen zurückgesetzt. Dann wird die gewürfelte Zahl zur Punktesumme des aktuellen Spielers addiert. Danach wird der Spielerwechsel durchgeführt. Dabei wird ein Ausdruck verwendet,

**[Video 11:19–11:50](https://www.youtube.com/watch?v=PGilCiIz16c&t=679)**

der zwar clever ist, aber anstrengend zu analysieren. Man hätte hier auch einfach den ternären Vergleichsoperator nehmen können, wie im vorherigen Programm. [Anm.: Gemeint ist der ternäre bedingte Operator (? :), kein Vergleichsoperator.] Ja klar. Gibt es sonst noch Besonderheiten, auf die du die Studierenden hinweisen möchtest? Ja, es gibt noch zwei Dinge. Erstens wird der Präfix-Inkrement-Operator verwendet, um die aufeinanderfolgenden Sechsen hochzuzählen. Bei diesem Operator wird ja zuerst die Variable erhöht und dann der Vergleich gemacht. Kann man hier schon machen, spart ja auch eine Zeile. Dafür muss man nun mehr mitdenken. Zweitens: Das Programm hat einen Fehler.

**[Video 11:50–12:20](https://www.youtube.com/watch?v=PGilCiIz16c&t=710)**

Oh wirklich? Du hast einen Fehler gefunden in meinem Code? Jetzt bin ich aber gespannt. Ja, das ist doch offensichtlich. Bei Gleichstand gewinnt Spieler zwei, weil vergessen wurde, einen else-if-Zweig einzubauen. Oh, wie gesagt, ich ich musste Platz sparen. Immerhin sehen die Studierenden jetzt, warum ein guter und ausführlicher Stil wichtig ist. Äh ja, ja stimmt. Und genau deswegen habe ich den Fehler ja auch eingebaut. So so.

### Folie 16

[Folie 16 als PDF](https://inf.zone/download/lectures/1-c/1.3-bedingungen.pdf#page=16)

```text
int currentPlayer = 1, consecutiveSixes = 0;
int roll = 3;
int sumPlayer1 = 15, sumPlayer2 = 12;

printf("Player %d rolled a %d.\n", currentPlayer, roll);
if (roll == 6) {
    if (++consecutiveSixes >= 3) {
        printf("Player %d rolled three sixes in a row!\n", currentPlayer);
        if (sumPlayer1 > sumPlayer2)
            printf("Player 1 wins!\n");
        else
            printf("Player 2 wins!\n");
    }
} else {
    consecutiveSixes = 0;
    if (currentPlayer == 1)
        sumPlayer1 += roll;
    else
        sumPlayer2 += roll;
    currentPlayer = (1 - (currentPlayer - 1)) + 1;
    printf("It's now Player %d's turn.\n", currentPlayer);
}
```

#### Transkript

> Zuordnung unsicher: wenige gemeinsame Textmerkmale; anhand der benachbarten Folien eingeordnet.

**[Video 12:20–12:27](https://www.youtube.com/watch?v=PGilCiIz16c&t=740)**

Dies war Inf-Einf-B.

### Folie 17 — Bedingte Anweisungen ermöglichen Entscheidungen

[Folie 17 als PDF](https://inf.zone/download/lectures/1-c/1.3-bedingungen.pdf#page=17)

if-Anweisungen führen Code

in Programmen basierend

aus, wenn eine Bedingung

wahr ist; else fügt einen alternativen Codeblock hinzu.

auf Variablenwerten oder

Benutzereingaben.

else if ermöglicht mehrere Bedingungen in einer Kette; die

switch-Anweisungen erlauben die Aufzählung diskreter Fälle

Reihenfolge ist wichtig.

statt boolescher Ausdrücke.

Guter Programmierstil (Einrückung, Leerzeichen, Klammernsetzung) verbessert

Der ternäre Operator (?:) ist eine Kurzform für einfache

if-else Zuweisungen.

Lesbarkeit und Wartbarkeit

des Codes.

> Bildinhalte sind nicht transkribiert; siehe Originalfolie.

#### Transkript

*Kein Transkriptabschnitt eindeutig dieser Folie zugeordnet. Möglicherweise eine Aufbau-/Grafikfolie oder eine Abweichung zwischen PDF und Video.*