# 1.2 Operatoren

Quelle: https://inf.zone/lectures/1-c/short-1-2-operatoren/

## Video

[Video ansehen](https://oc.streams.uni-bamberg.de/paella7/ui/watch.html?id=d50b2be0-7099-4747-9a9c-4caff0c78630)

### Alternativen

- [Video auf YouTube](https://youtu.be/NShF4U4bBLQ)
- 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 12, Frage F2: Die Ganzzahldivision 5 / 2 ergibt 2, nicht 0. Gemeint ist: Warum bekomme ich 2 statt 2.5?

## Material

- [Folien](https://inf.zone/download/lectures/1-c/1.2-operatoren.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 — Operatoren

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

#### Transkript

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

Dies ist Inf-Einf-B.

### Folie 2

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

Operatoren sind Symbole, die den Compiler anweisen, bestimmte mathematische oder logische Manipulationen durchzuführen. Operatoren arbeiten mit Operanden, die Variablen, Konstanten oder Ausdrücke sein können. Die Kombination von Operatoren und Operanden bildet Ausdrücke.

#### Transkript

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

Heute Operatoren. Operatoren sind Symbole, die den Compiler anweisen, bestimmte mathematische oder logische Manipulationen durchzuführen. Operatoren arbeiten mit Operanden, die Variablen, Konstanten oder Ausdrücke sein können. Die Kombination von Operatoren und Operanden bildet Ausdrücke. Ernsthaft?

### Folie 3

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

In C gibt es zahlreiche Operatoren. Wir betrachten hier nur die wichtigsten. Andere stellen wir später an den passenden Stellen vor.

Wir beginnen mit arithmetischen Operatoren. Dann schauen wir uns Vergleichsoperatoren und logische Operatoren an. Unterwegs behandeln wir einige Zuweisungsoperatoren.

#### Transkript

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

Ich habe dir doch beim letzten Mal schon gesagt, dass du nicht zu formal anfangen sollst. Der Kurs heißt doch Einführung in die Informatik.

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

Ich führe hier wichtige Begriffe aus der Informatik ein. Ja, aber das geht doch auch etwas enthusiastischer. Zum Beispiel so: Heute schauen wir uns Operatoren an. Operatoren brauchen wir in C nicht nur zum Rechnen, sondern auch um zu entscheiden, wie sich unser Programm verhalten soll. Operatoren und Operanden, das sind zum Beispiel Literale und Variablen, bilden Ausdrücke. Wir sollten jetzt aber mal anfangen, sonst geht uns noch die Zeit aus. In C gibt es zahlreiche Operatoren. Wir betrachten hier nur die wichtigsten. Andere stellen wir später an den passenden Stellen vor. Wir beginnen mit arithmetischen Operatoren.

**[Video 01:04–01:37](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=64)**

Dann schauen wir uns Vergleichsoperatoren und logische Operatoren an. Unterwegs behandeln wir einige Zuweisungsoperatoren, arithmetische Operatoren und Zuweisungen.

### Folie 4 — Arithmetische

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

Den Zuweisungsoperator (`=`) haben wir bereits kennengelernt. Damit können wir einen Wert in eine Variable einfügen.

Operatoren und Zuweisung

Arithmetische Operatoren erlauben grundlegende mathematische Operationen: Addition (`+`), Subtraktion (`-`), Multiplikation (`*`) und Division (`/`).

Beispiele:

```text
int y = 10;
int x = y + 1;
x = x * 5;
x = x + 3 * y;
```

Bei einer Zuweisung wird zuerst der Wert rechts vom `=` berechnet und dann der Variablen links davon zugewiesen.

#### Transkript

**[Video 01:04–01:37](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=64)**

Den Zuweisungsoperator ist gleich haben wir bereits kennengelernt. Damit können wir einen Wert in eine Variable einfügen. Arithmetische Operatoren führen grundlegende mathematische Operationen aus: Addition plus, Subtraktion minus, Multiplikation Sternchen und Division Schrägstrich. Die Beispiele zeigen, wie man Operatoren verwendet, wenn y gleich zehn

**[Video 01:37–02:09](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=97)**

ist, erhält x den Wert elf und wenn x vorher elf war, hat es danach den Wert fünfundfünfzig. Bei einer Zuweisung wird immer zuerst der Wert rechts vom ist gleich berechnet und dann der Variablen links davon zugewiesen. Genau, die letzte Zeile hast du jetzt aber unterschlagen.

### Folie 5 — ModuloOperator

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

Der Modulo-Operator (`%`) gibt den Rest an, wenn zwei Zahlen geteilt werden.

Beispiel:

```text
int m = 13 % 4; // m ist jetzt 1
```

Es gibt einige praktische Anwendungen beim Programmieren. Beispiele:

1. Schattierung jeder zweiten Zeile in einer Tabelle, d.h. alle Zeilen für die gilt, dass `rowNumber` `% 2` gleich 0 ist.

2. Generierung von Zufallszahlen innerhalb eines gewünschten Bereichs.

#### Transkript

**[Video 01:37–02:09](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=97)**

Es gilt hier Punkt vor Strich. Wenn x also fünfundfünfzig ist und y immer noch zehn, dann haben wir fünfundfünfzig plus dreißig also fünfundachtzig. Wenn man sich nicht sicher ist, kann man auch einfach Klammern setzen, um die Ausführungsreihenfolge oder Auswertungsreihenfolge festzulegen. Modulo-Operator.

**[Video 02:09–02:39](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=129)**

Der Modulo-Operator Prozent gibt den Rest an, wenn zwei Zahlen geteilt werden. Im Beispiel bekommt m den Wert 1, weil 3 mal 4 ist 12 mit Rest 1. Der Modulo-Operator erscheint vielleicht auf den ersten Blick nicht so nützlich, hat aber viele praktische Anwendungen beim Programmieren. Zum Beispiel kann man damit jede zweite Zeile in einer Tabelle schattieren, also alle Zeilen, für die gilt, dass rowNumber Modulo 2 gleich 0 ist. Oder man kann damit Zufallszahlen innerhalb eines gewünschten Bereichs generieren.

### Folie 6 — Kurzformen

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

Für einige Operatoren gibt es eine Kurzform. Beispiel:

`x` `*=` `5``;` ist das gleiche wie `x` `=` `x` `*` `5``;`

Solche Operatoren gibt es für alle grundlegenden arithmetischen Operatoren: `+`, `-`, `*`, `/`, `%`

Es gibt auch eine Kurzform für das Erhöhen oder Verringern um 1:

`x++` inkrementiert x

`x--` dekrementiert x

Der Code sieht dadurch eleganter aus. Die Verwendung ist optional.

#### Transkript

**[Video 02:09–02:39](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=129)**

Kurzformen.

**[Video 02:39–03:08](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=159)**

Für einige Operatoren gibt es eine Kurzform für die Anwendung arithmetischer Operatoren auf eine bestimmte Variable. Zum Beispiel ist x Sternchen ist gleich fünf das Gleiche wie die Zuweisung x ist gleich x mal fünf. Solche Operatoren gibt es für alle grundlegenden arithmetischen Operatoren: Plus, Minus, Mal, geteilt und Modulo. Es gibt auch eine Kurzform für das Erhöhen oder Verringern um eins. Man schreibt dazu x++, man sagt dazu auch x wird inkrementiert. x-- bedeutet x wird dekrementiert.

**[Video 03:08–03:36](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=188)**

Diese Kurzformen müssen nicht verwendet werden. Der Code sieht dadurch halt prägnanter und eleganter aus. Es ist auf jeden Fall wichtig, sie zu kennen, damit man fremden Code verstehen kann. Absolut. Vielleicht noch als Ergänzung: Verwendet werden die Kurzformen vor allem ganz gern in Schleifen, über die wir noch reden werden, wenn man eine bestimmte Variable hochzählen will, jedes Mal, wenn die Schleife durchlaufen wird. Man muss aber wirklich aufpassen, dass man es nicht übertreibt.

### Folie 7 — Boolesche Ausdrücke

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

… sind entweder wahr oder falsch. Grundlage für Entscheidungen in Programmen; steuern Ablauf der Ausführung („control flow“):

Welche Verzweigung soll in einer Bedingung genommen werden?

Soll eine Schleife weiterlaufen?

Nicht notwendig, bool zu verwenden, ein int geht bspw. auch.

In C wird jeder Wert, der nicht 0 ist, als true angesehen – also nicht nur die 1.

Nur die 0 ist false.

#### Transkript

**[Video 03:08–03:36](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=188)**

Wenn man es übertreibt, kann man sehr schnell komplizierten und schlecht lesbaren Code schreiben.

**[Video 03:36–04:05](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=216)**

Oft ist es auch besser, die komplizierten Ausdrücke aufzuteilen und ausdrucksstarke Namen zu verwenden, so dass man die Zwischenergebnisse auch sehen kann, damit man auch nach längerer Zeit, also nach ein paar Monaten, noch gut nachvollziehen kann, was man sich gedacht hat, als man den Code geschrieben hat. Boolsche Ausdrücke. Boolsche Ausdrücke sind entweder wahr oder falsch. Sie sind die Grundlage für Entscheidungen in Programmen, steuern also den Ablauf der Ausführung. Das nennt man auch den Kontrollfluss.

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

Oder im Englischen Control Flow. Dazu gehören beispielsweise Entscheidungen, welche Verzweigungen in einer Bedingung genommen werden sollen, oder das Feststellen, ob eine Schleife weiterlaufen soll oder nicht. Es ist nicht notwendig, dafür immer Variablen vom Typ Bool zu verwenden. Ein Int geht auch. Wenn Sie Bool verwenden wollen, denken Sie daran, dass Sie dazu cs50.h in Ihr Programm einbinden müssen. Dass auch ein Int geht, liegt daran, dass in C jeder Wert, der nicht null ist, als wahr angesehen wird und nur die Null als falsch.

### Folie 8 — Logische Operatoren

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

Logisches UND (`&&`): wahr, wenn beide Operanden wahr sind, sonst falsch; Ergebnis ist 0 (falsch) oder 1 (wahr)

Logisches ODER (`||`): wahr, wenn mind. einer der Operanden wahr ist, sonst falsch; Ergebnis ist 0 oder 1

Logisches NICHT (`!`): invertiert den Wert eines Operanden; Ergebnis ist 0 oder 1

Beispiel:

```text
int x = 1 && 0;
int y = !x;
int z = x || y; // z ist nun 1
```

#### Transkript

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

Also ist beispielsweise die Eins wahr, aber auch die 100. Logische Operatoren.

**[Video 04:40–05:06](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=280)**

Logische Operatoren geben entweder null oder eins zurück. Null, wenn das Ergebnis falsch ist, eins, wenn es wahr ist. Logisches und, zweimal Kaufmanns-Und. Der Ausdruck ist wahr, wenn beide Operanden wahr sind, sonst falsch. Logisches oder, zweimal Senkrechtstrich. Der Ausdruck ist wahr, wenn mindestens einer der Operanden wahr ist, sonst falsch. Logisches nicht, Ausrufezeichen. Invertiert den Wert eines Operanden. Schauen wir uns ein Beispiel an.

**[Video 05:06–05:38](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=306)**

Zuerst haben wir 1 und und 0. Es sind nicht beide Operanden wahr, also bekommt x den Wert 0. In der zweiten Zeile wird der Wert von x invertiert. x ist aktuell falsch, also wird es wahr. y wird daher auf 1 gesetzt. In der dritten Zeile haben wir einen Oder-Operator. Der evaluiert zu wahr, wenn mindestens ein Operand, also einer oder beide Operanden, wahr sind. Das ist hier der Fall, weil y ja 1 ist.

### Folie 9 — Vergleichs-

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

Die Vergleichsoperatoren von C verhalten sich ähnlich wie elementare arithmetische Vergleiche.

operatoren

Sie geben 0 (für falsch) oder 1 (für wahr) zurück. Folgende Vergleiche existieren:

```text
x < y
```

kleiner als

`x <= y` kleiner als oder gleich

```text
x > y
```

größer als

`x >= y` größer als oder gleich

`x == y` Gleichheit

`x != y` Ungleichheit

#### Transkript

**[Video 05:06–05:38](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=306)**

Also wird z ebenfalls 1. Und vielleicht noch ein Hinweis: Den Senkrechtstrich, also die Pipe, findet man auf den meisten Tastaturen neben der linken Umschalttaste.

**[Video 05:38–06:05](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=338)**

Man muss dazu noch bei Windows zumindest Alt Gr drücken, um die Taste dann zum Senkrechtstrich zu machen. Bei macOS drückt man einfach Option sieben. Vergleichsoperatoren. Die Vergleichsoperatoren von C verhalten sich ähnlich wie arithmetische Vergleiche. Sie geben null für falsch oder eins für wahr zurück. Es gibt kleiner als, kleiner oder gleich, größer als und größer oder gleich. Außerdem kann man Werte auf Gleichheit oder Ungleichheit prüfen.

**[Video 06:05–06:38](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=365)**

Stimmt, auf jeden Fall. Achten Sie aber darauf, dass Sie bei Vergleichen unbedingt immer den Gleichheitsoperator verwenden, also den mit zwei ist gleich und nicht etwa den mit einem ist gleich. Wenn man die verwechselt, kommt es zu total unvorhersehbaren und unerwarteten Verhalten. In Bedingungen, also wenn wir später if verwenden, dann will man fast immer den Gleichheitsoperator und fast nie den Zuweisungsoperator verwenden. Falls man doch mal den Zuweisungsoperator erwischt, dann führt es eben dazu, dass eine Zuweisung durchgeführt wird, aber eben kein Vergleich. Und wenn der Wert, den man zuweist, von null verschieden ist, dann evaluiert

**[Video 06:38–07:11](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=398)**

der boolesche Ausdruck zu wahr, ja und es wird nebenbei auch noch eine Variable verändert, die man gar nicht verändern wollte. In jedem Fall wird aber nicht der Vergleich durchgeführt, den man ursprünglich im Sinn hatte. Vorsicht also an der Stelle. Wenn Sie Fließkomma-Zahlen auf Gleichheit prüfen, müssen Sie außerdem beachten, dass es Probleme mit der Genauigkeit geben kann. Oft ist es besser zu prüfen, ob die Differenz zwischen zwei Fließkomma-Zahlen kleiner ist als eine sehr kleine Zahl ε.

### Folie 10 — Überblick

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

Operator: Symbol, das den Rechner anweist, mathematische oder logische Manipulationen durchzuführen.

Operand: Wert, auf den ein Operator wirkt, z.B. Variable, Literal oder Ausdruck.

Ausdruck (expression): Kombination aus Operatoren und Operanden (oder einzelnes Literal oder Variable); Ausdrücke werden zu einem einzigen Wert ausgewertet.

Zuweisung (assignment): Spezieller Ausdruck mit Seiteneffekt: weist einer Variablen einen Wert zu.

Boolescher Ausdruck: Ausdruck, der als wahr oder falsch ausgewertet wird.

#### Transkript

**[Video 06:38–07:11](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=398)**

Kannst du zum Abschluss die bisherigen Konzepte vielleicht noch mal im Überblick zeigen, aber bitte mit einer Folie, die sich nach und nach aufbaut, also animiert ist?

**[Video 07:11–07:38](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=431)**

Aber natürlich, wir haben folgende Konzepte gesehen: Operatoren sind Symbole, die den Rechner anweisen, bestimmte mathematische oder logische Manipulationen durchzuführen. Operanden sind Werte, auf die ein Operator wirkt, etwa Variablen, Literale oder Ausdrücke. Ein Ausdruck ist eine Kombination aus Operatoren und Operanden. Aber auch ein Literal oder eine Variable ist ein Ausdruck. Alles, was zu einem einzigen Wert ausgewertet wird, ist ein Ausdruck.

**[Video 07:38–08:13](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=458)**

Eine Zuweisung ist ein spezieller Ausdruck, der einen Seiteneffekt hat, nämlich, dass einer Variablen ein Wert zugewiesen wird. Und dann gibt es noch Boolesche Ausdrücke. Das sind Ausdrücke, die als wahr oder falsch ausgewertet werden.

### Folie 11

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

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 07:38–08:13](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=458)**

Jetzt willst du garantiert noch deine drei Extraminuten machen, oder? Ja, ganz genau. Die drei Extraminuten. Was machen wir heute? Wie wäre es mit ein paar aktivierenden Fragen zum Aufwärmen? In Ordnung. Hier sind ein paar Fragen. Ah, F2 hat ja gar nichts mit dem Inhalt dieses Videos zu tun, sondern mit dem Video vom vorherigen Mal.

**[Video 08:13–08:45](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=493)**

Zu Datentypen. Ist das Absicht? Ja, genau. Indem wir eine Frage aus der Vorwoche unter die Fragen dieser Woche mischen, verwenden wir das, was Forscher ein gemischtes Format oder Shuffle-Format nennen. Dieser Ansatz fordert die Lernenden heraus, herauszufinden, welche Konzepte sie bei jeder Frage anwenden müssen, anstatt einfach davon auszugehen, dass sich alle Fragen auf den neuesten Stoff beziehen. Dadurch verbessert sich ihre Fähigkeit, zwischen verschiedenen Problemtypen zu unterscheiden und die richtige Strategie zu wählen. Sehr gut. Ah, ich mag auch die letzte Frage.

### Folie 12

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

Welchen Wert hat x jetzt? F1:

```text
int x = 10; x *= 3; x %= 7;
```

Warum bekomme ich bei `5` `/` `2` als Ergebnis die Zahl 2 statt 2.5? F2:

Wie prüft man mit Operatoren am einfachsten, ob eine Zahl gerade ist? F3:

F4:

Wird der Ausdruck als wahr (1) ausgewertet?

```text
(5 + 3>7) && (4 * 2 == 8)
```

Operator-Rangfolge (operator precedence) beachten!

#### Transkript

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

**[Video 08:45–09:17](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=525)**

Die ist ziemlich clever gestellt. Du meinst, weil man erst denkt, dass drei und sieben miteinander verglichen werden, weil keine Leerzeichen dazwischen geschrieben stehen? Ja, das habe ich absichtlich so gemacht. Die Frage soll zeigen, dass es in C eine festgelegte Rangfolge unter den Operatoren gibt, in der Ausdrücke ausgewertet werden. Das Plus bindet stärker als der Vergleichsoperator. Mehr dazu findet man unter dem Stichwort Operatorrangfolge. Im Englischen sagt man dazu Operator precedence. Ganz genau.

### Folie 13

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

Was passiert in diesem Programm?

> Bildinhalte sind nicht transkribiert; siehe Originalfolie.

> Vorwiegend grafische Folie; die extrahierten Beschriftungen ersetzen die Abbildung nicht.

#### Transkript

**[Video 08:45–09:17](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=525)**

Wie gesagt, wenn man sich nicht sicher ist, ist es einfach eine gute Idee, Klammern zu setzen.

**[Video 09:17–09:42](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=557)**

Nun habe ich eine Frage. Was passiert eigentlich in diesem Programm? Das gezeigte Programm hat ein paar interessante Zuweisungen und Vergleiche. Gehen wir Zeile für Zeile durch, um es zu verstehen. Zeile vier: int a ist gleich fünf, b ist gleich zehn, c. Hier werden drei Variablen deklariert, zwei davon werden initialisiert: a mit fünf, b mit zehn. Zeile sechs: c gleich a gleich b. Diese Zeile enthält zwei Zuweisungen.

**[Video 09:42–10:10](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=582)**

Zuerst wird a gleich b ausgewertet, weil wir ja immer von rechts auswerten. Dadurch erhält a den Wert von b, also zehn. Das Ergebnis der Zuweisung a gleich b ist der neue Wert von a, der gleichzeitig b entspricht, also zehn. Anschließend wird dieser Wert c zugewiesen. Nach dieser Zeile haben sowohl a als auch c den Wert zehn. Zeile sieben: printf Prozent d Backslash n mit dem Parameter c gleich a gleich b gleich zwanzig in Klammern ist gleich ist gleich zwanzig. Diese Zeile ist etwas komplizierter.

**[Video 10:10–10:44](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=610)**

Zuerst wird die Zuweisung von rechts nach links ausgeführt. b gleich 20 setzt b auf 20. a gleich b setzt a auf den neuen Wert von b, also ebenfalls 20. c gleich a setzt c auf den Wert von a, also 20. Danach wird die gesamte Zuweisung, also c gleich a gleich b gleich 20, ausgewertet. Das Ergebnis ist 20. Der Vergleich ist also 20 ist gleich ist gleich 20. Dieser Vergleich ergibt eins. Wunderbar. Jetzt haben wir also noch einmal gesehen, dass Zuweisungen nicht nur Variablen ändern, sondern auch ein Ausdruck sind, also zu einem Wert evaluieren. Mir fällt noch ein Detail ein, das wir nicht behandelt haben.

**[Video 10:44–11:12](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=644)**

Schau dir einmal dieses Programm an. Oh, ich glaube, das ist für den Anfang gar nicht so wichtig. Aber du kannst ja kurz erklären, was hier passiert. Gerne.

### Folie 14

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

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

```c
#include <stdio.h>

int main() {
    int a = 5, b = 5;
    
    // Using postfix increment
    int r1 = (a++ == 5);
    printf("a = %d, r1 = %d\n", a, r1);
    
    // Using prefix increment
    int r2 = (++b == 5);
    printf("b = %d, r2 = %d\n", b, r2);
    
    return 0;
}
```

#### Transkript

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

**[Video 10:44–11:12](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=644)**

Zeile fünf: Die zwei Variablen a und b werden mit dem Wert fünf initialisiert. Danach wird in Zeile acht a inkrementiert, also um eins erhöht. Das haben wir vorhin besprochen. Man nennt diese Variante auch Postfix-Inkrementierung, weil das ++ hinter der Variable steht. Ein Detail, das hier jetzt wichtig wird, haben wir aber bisher ignoriert.

**[Video 11:12–11:44](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=672)**

Und zwar bedeutet der Ausdruck a++, dass in der Vergleichsoperation noch der aktuelle Wert von a, welcher 5 ist, verwendet wird und erst danach a um 1 erhöht wird. Da a zum Zeitpunkt des Vergleichs noch 5 ist, ergibt der Ausdruck a++ gleich gleich 5 den Wert 1. Erst danach wird a auf 6 erhöht. r1 wird daher auf 1 gesetzt. In Zeile 12 kommt dann die Präfix-Inkrementierung, da ist die Reihenfolge genau andersherum. Der Ausdruck ++b erhöht den Wert von b zuerst um 1, bevor er in der Vergleichsoperation verwendet wird.

**[Video 11:44–12:15](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=704)**

r zwei wird daher auf null gesetzt und die Ausgabe lautet b ist gleich sechs r zwei ist gleich null. Zusammenfassend kann man also sagen, das Postfix-Inkrement verwendet den aktuellen Wert und erhöht ihn danach. Das Präfix-Inkrement erhöht den Wert zuerst und verwendet dann den neuen Wert im Ausdruck. Wenn man erst gerade anfängt C zu lernen, ist es aber meist besser, auf solche Kurzformen zu verzichten, damit man nicht so viel mitdenken muss, was der Code tut.

### Folie 15

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

```text
Ist a 0? => 0 
Ist b 0? => 0 
Dann muss a AND b 1 sein. 
a AND b: 0 
Nanu?
```

```c
#include <stdio.h>

int main() {
    int a = 10, b = 5;
    
    printf("Ist a 0? => %d\n", a == 0);
    printf("Ist b 0? => %d\n", b == 0);
    printf("Dann muss a AND b 1 sein.\n");
    printf("a AND b: %d\n", a & b);
    printf("Nanu?\n");
    
    return 0;
}
```

Rätselfrage

#### Transkript

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

**[Video 11:44–12:15](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=704)**

Okay, ich hätte hier noch eine letzte Aufgabe. Oben rechts siehst du die Ausgabe des Programms. Was ist hier los?

**[Video 12:15–12:48](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=735)**

Ah, das ist auch eine schöne Aufgabe. Da kann man auch was lernen. Am besten hält man hier kurz das Video an und sucht erstmal den Fehler. So, erkläre doch mal, was das Problem ist. Statt des logischen Und-Operators zweimal Kaufmanns-Und wurde hier versehentlich der bitweise Und-Operator benutzt. Das ist nur ein Kaufmanns-Und. Das musst du jetzt echt kurz erklären. Bitweise Operatoren haben wir doch noch gar nicht behandelt und wir brauchen sie in unserem Kurs wahrscheinlich ja auch gar nicht. Schon, aber sollte zumindest wissen.

**[Video 12:48–13:18](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=768)**

dass es sie gibt, um keine Fehler zu machen. A und B ist eine bitweise UND-Operation. Um zu verstehen, wie diese Operation funktioniert, schauen wir uns die beiden Zahlen im Binärsystem an. Zehn als Binärzahl ist 1010, weil zehn ist ja acht plus zwei. Fünf als Binärzahl ist 0101, weil fünf ja vier plus eins ist. Ein bitweises UND geht die beiden Zahlen parallel, stellenweise durch und verknüpft die Bits an der jeweils aktuellen Stelle mit einer UND-Verknüpfung. Im Ergebnis sind also nur die Stellen eins, die in beiden Operanden eins waren.

**[Video 13:18–13:44](https://www.youtube.com/watch?v=NShF4U4bBLQ&t=798)**

Das Ergebnis ist null null null, also falsch, weil eins null eins null und null eins null eins in keiner Stelle beide ein Bit auf eins gesetzt haben. So weit, so gut. Weißt du was? Die Zeit ist um. Oh, stimmt. Bis bald. Dies war Inf-Einf-B.

### Folie 16 — Arithmethische Operatoren

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

Operanden sind Variablen, Konstanten oder Ausdrücke.

+, -, \*, / % (Modulo)

Ausdrücke haben einen Wert.

Zuweisung (=): Ausdruck mit Seiteneffekt

Vergleichsoperatoren \<, \<=, \>, \>= sowie ==, !=

Kurzformen (+= usw.)

Ergebnis ist 0 oder 1 Grundlage für Entscheidungen

Inkrement (++)

im Programmablauf

Dekrement (– –)

Boolesche Ausdrücke: Jeder Wert ≠ 0 ist wahr, nur 0 falsch

Auswertungsreihenfolge

(rechts nach links) und

Logische Operatoren &&, || und !

Operatorrangfolge. Achtung, Unterschied: &&, || und &, | sowie = und ==

Steuern den Programmfluss (z.B. in Bedingungen, Schleifen)

> 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.*