# 1.6 Magic Numbers

Quelle: https://inf.zone/lectures/1-c/short-1-6-magic-numbers/

## Video

[Video ansehen](https://oc.streams.uni-bamberg.de/paella7/ui/watch.html?id=ad1f6a7a-1c28-45f8-a043-ebae93e00460)

### Alternativen

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

## Material

- [Folien](https://inf.zone/download/lectures/1-c/1.6-magic-numbers.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 — Magische Zahlen

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

#### Transkript

**[Video 00:00–00:29](https://www.youtube.com/watch?v=sqll2929L-U&t=0)**

Dies ist Inf-Einf-B.

### Folie 2

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

Beim Programmieren schreibt man mitunter Zahlen in den Code, deren Bedeutung für andere auf den ersten Blick nicht klar ersichtlich ist. Warum sind diese problematisch und wie können wir besser damit umgehen?

#### Transkript

**[Video 00:00–00:29](https://www.youtube.com/watch?v=sqll2929L-U&t=0)**

Heute Magic Numbers. In der Programmierung stoßen wir oft auf Zahlen in unserem Code, deren Bedeutung auf den ersten Blick nicht klar ersichtlich ist. Warum diese problematisch sein können und wie wir besser damit umgehen, schauen wir uns in diesem Video an. Oh, nanu? Heute steigst du aber informell ein. Ich dachte, du stehst hier für Präzision und akkurate Definitionen von Konzepten. Definitiv. Ich kann gerne einen formaleren Einstieg erzeugen.

### Folie 3 — Solche festen Werte nennt man auch Magic Numbers oder „Magische Zahlen“.

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

Einige der Programme, die wir uns angeschaut haben, enthalten möglicherweise auch solche magischen Zahlen.

#### Transkript

**[Video 00:29–00:57](https://www.youtube.com/watch?v=sqll2929L-U&t=29)**

Ne, ne, ist schon recht so. Solche festen Werte nennt man beim Programmieren auch Magic Numbers. Also letztes Mal war es das magische Fenster, dieses Mal sind es die magischen Zahlen. Im nächsten Video kämpfen wir dann gegen Drachen, oder? Ha, ha, sehr witzig. Nein, der Begriff mag zunächst etwas seltsam klingen, aber so ist das halt. Also weiter. Einige der Programme, die wir uns angeschaut haben, enthalten möglicherweise auch solche magischen Zahlen.

**[Video 00:57–01:23](https://www.youtube.com/watch?v=sqll2929L-U&t=57)**

Ich mache mal ein Beispiel.

### Folie 4 — Beispiel: Block-Pyramide in einem Super-Mario-Spiel

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

Pyramidenhöhe: maximal 23

Es fehlt Kontext, z.B.: Höhe des Terminalfensters ist standardmäßig 24 Zeilen.

Dadurch schlechte Lesbarkeit und erschwerte Wartung des Codes.

#### Transkript

**[Video 00:57–01:23](https://www.youtube.com/watch?v=sqll2929L-U&t=57)**

Stellen wir uns vor, Sie werden gefragt, auf der Konsole eine Pyramide auszugeben, wie sie am Ende eines Levels im Spiel Super Mario vorkommt. In der Aufgabenstellung heißt es, die maximale Höhe der Pyramide soll 23 sein. Aber was bedeutet diese 23 eigentlich? Wenn jemand Ihren Code anschaut, ist die Bedeutung von 23 dann sofort ersichtlich? Nehmen wir an, der Grund für diese Begrenzung wäre, dass die Standardhöhe eines Terminalfensters 24

**[Video 01:23–01:49](https://www.youtube.com/watch?v=sqll2929L-U&t=83)**

Zeilen beträgt. Wenn die Pyramide höher wäre, könnte sie über den Bildschirmrand hinauslaufen. Aber ist diese Bedeutung für jemanden offensichtlich, der Ihr Programm betrachtet und vielleicht ein anderes konfiguriertes Terminalfenster hat? Wahrscheinlich nicht. Im Allgemeinen ist es keine gute Angewohnheit, Konstanten direkt in den Code zu schreiben.

### Folie 5

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

```text
card deal_cards(deck name)
{
    for (int i = 0; i < 52; i++)
    {
        // Karte austeilen
    }
}
```

Sehen Sie die Magic Number?

Sehen Sie, dass hier ein Problem entstehen könnte? Etwa, wenn diese Funktion eine von mehreren ist, die Kartenspiele manipulieren.

#### Transkript

**[Video 01:23–01:49](https://www.youtube.com/watch?v=sqll2929L-U&t=83)**

Wenn wir das trotzdem tun, wird man mitunter dafür kritisiert, dass man Magic Numbers verwendet, etwas, das wir in der Regel vermeiden sollten.

**[Video 01:49–02:19](https://www.youtube.com/watch?v=sqll2929L-U&t=109)**

Lassen Sie uns nun ein konkretes Beispiel betrachten, um das Problem der Magic Numbers besser zu verstehen. Stellen Sie sich folgende einfache Funktion vor. Es gibt doch gar keinen Datentyp Card und auch kein Deck in C. Und mit Funktionen haben sich die Studierenden zum jetzigen Zeitpunkt ja vielleicht auch noch gar nicht beschäftigt. Ja, aber das ist jetzt egal. Das hier ist eine Mischung aus Pseudocode und C-Code. Auf diese Details kommt es hier aber gar nicht an. Lass mich jetzt mal weiter Magic Numbers erklären. Also

**[Video 02:19–02:49](https://www.youtube.com/watch?v=sqll2929L-U&t=139)**

Sehen Sie die Magic Number in diesem Code? Noch wichtiger: erkennen Sie das potenzielle Problem hier? Besonders wenn diese Funktion nur eine von vielen in einem Programm ist, das mit Kartenspielen zu tun hat. Die Magic Number ist 52. Vielleicht wussten Sie vorher schon, dass ein Standardkartenspiel 52 Karten enthält. Aber in unserem Programm schwebt diese Zahl einfach so im Code herum. Da ist plötzlich eine 52 ohne jeglichen Kontext. Stellen Sie sich vor, diese Funktion wäre in einer Datei in einem Ordner mit vielen anderen Dateien

**[Video 02:49–03:15](https://www.youtube.com/watch?v=sqll2929L-U&t=169)**

von denen jede etwas anderes mit einem Kartendeck macht. Vielleicht mischt eine andere Funktion in einer anderen Datei die Karten oder eine weitere teilt eine Hand mit fünf Karten aus anstatt einer einzelnen Karte. Das Problem hier ist, dass die Bedeutung von 52 nicht sofort ersichtlich ist, wenn man den Code liest. Außerdem könnte es schwierig werden, wenn wir in Zukunft mit anderen Kartenspielen arbeiten wollen, die eine andere Anzahl von Karten verwenden.

### Folie 6 — Erster Lösungsversuch

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

```text
card deal_cards(deck name)
{
    int deck_size = 52;
    for (int i = 0; i < deck_size; i++)
    {
        // Karte austeilen
    }
}
```

Das behebt ein Problem, führt aber zu einem anderen.

Wenn deck\_size global deklariert würde, könnte es passieren, dass eine andere Funktion in unserem Programm deck\_size versehentlich manipuliert.

#### Transkript

**[Video 02:49–03:15](https://www.youtube.com/watch?v=sqll2929L-U&t=169)**

Ein erster Lösungsversuch. Nun, wie könnten wir dieses Problem lösen?

**[Video 03:15–03:41](https://www.youtube.com/watch?v=sqll2929L-U&t=195)**

Ein erster Ansatz könnte so aussehen. Diese Lösung behebt ein Problem, führt aber ein anderes ein. Wir haben der Zahl 52 jetzt zwar einen Namen gegeben, was die Bedeutung etwas klarer macht. Es sieht besser aus, deck_size in der for-Schleife zu verwenden, als einfach 52 zu schreiben. Aber auch wenn wir diese Variable global deklarieren würden, Sie erinnern sich doch noch an den Unterschied zwischen globalen und lokalen Variablen, nicht wahr? Könnte es immer noch zu Problemen kommen.

**[Video 03:41–04:12](https://www.youtube.com/watch?v=sqll2929L-U&t=221)**

Moment mal, unsere Studierenden haben vielleicht noch gar nichts über den Unterschied zwischen lokalen und globalen Variablen gelernt. Möglicherweise kennen sie auch den Begriff Scope noch gar nicht. Wenn du schon Querverweise einbaust, dann musst du aufpassen, dass die Studierenden dir folgen können, sonst sind sie verwirrt. Da hast du jetzt wirklich einmal recht. Scope kommt erst noch. Lass mich das also kurz erklären. Fürs Erste reicht es zu sagen, dass der Scope einer Variable der Bereich im Code ist, in dem diese Variable sichtbar und nutzbar ist. Eine lokale Variable.

**[Video 04:12–04:43](https://www.youtube.com/watch?v=sqll2929L-U&t=252)**

Ist nur innerhalb der Funktion verfügbar, in der sie definiert wurde. Eine globale Variable hingegen ist im gesamten Programm sichtbar. Globale Variablen sind solche, die außerhalb einer Funktion deklariert werden. Das Problem mit globalen Variablen ist, dass sie von jeder Funktion im Programm geändert werden können. Das macht es schwer, den Überblick zu behalten und kann zu unerwarteten Fehlern führen. Lokale Variablen sind sicherer, da sie nur in ihrer eigenen Funktion existieren. Aber das bedeutet auch, dass wir sie nicht direkt in anderen Teilen unseres Programms verwenden können. So.

**[Video 04:43–05:12](https://www.youtube.com/watch?v=sqll2929L-U&t=283)**

Wo waren wir? Ah, was wäre, wenn eine andere Funktion in unserem Programm versehentlich deck_size manipuliert? Was, wenn sie den Wert um eins erhöht oder verringert? Das könnte ernsthafte Schwierigkeiten verursachen. Stellen Sie sich vor, wir haben eine Funktion, die das gesamte Deck mischen soll. Wenn deck_size versehentlich um eins auf 51 verringert wird, mischen wir nicht mehr alle Karten. Wir lassen eine aus. In einem Kartenspiel könnte das fatale Folgen haben. Diese Lösung ist also ein Schritt in die richtige Richtung, aber noch nicht perfekt.

### Folie 7 — Präprozessor-Direktive #define

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

C bietet die Möglichkeit, mit einer Präprozessor-Direktive (auch Makro genannt) symbolische Konstanten zu erstellen.

```text
#define NAME ERSATZ
```

Beim Kompilieren Ihres Programms durchsucht der Kompiler Ihren Code und ersetzt NAME durch ERSATZ.

#include ist also wie Kopieren/Einfügen, #define wie Suchen/Ersetzen.

#### Transkript

**[Video 05:12–05:44](https://www.youtube.com/watch?v=sqll2929L-U&t=312)**

Wir brauchen eine Möglichkeit, die Bedeutung der Zahl klar zu machen, ohne dass sie versehentlich geändert werden kann. Die Lösung: Präprozessordirektiven. C bietet uns eine elegante Lösung für dieses Problem. Präprozessordirektiven, auch Makros genannt. Diese ermöglichen es uns, symbolische Konstanten zu erstellen. Eine Präprozessordirektive, die Sie vielleicht schon kennen, ist include. Heute lernen wir eine weitere kennen: define. Die Syntax sieht so aus. Ja, ein wichtiger Hinweis gleich: Setzen Sie kein Semikolon ans Ende Ihrer define-Anweisungen.

**[Video 05:44–06:09](https://www.youtube.com/watch?v=sqll2929L-U&t=344)**

Stimmt, genau. Also passiert hier eigentlich? Wenn Ihr Programm kompiliert wird, geht der Compiler durch Ihren Code und ersetzt jedes Vorkommen von Name durch Ersetzung. Wenn Include einer Kopier- und Einfügeoperation ähnelt, dann ist Define vergleichbar mit einer Suchen- und Ersetzen-Funktion, wie Sie sie vielleicht aus Textverarbeitungsprogrammen kennen.

### Folie 8 — Präprozessor-Direktive #define

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

C bietet die Möglichkeit, mit einer Präprozessor-Direktive (auch Makro genannt) symbolische Konstanten zu erstellen.

```text
#define PI 3.14159265
```

Beim Kompilieren Ihres Programms durchsucht der Kompiler Ihren Code und ersetzt `PI` durch `3.14159265`.

#include ist also wie Kopieren/Einfügen, #define wie Suchen/Ersetzen.

#### Transkript

**[Video 05:44–06:09](https://www.youtube.com/watch?v=sqll2929L-U&t=344)**

Lassen Sie uns ein Beispiel betrachten: define PI 3,14 und so weiter. Wenn Sie mathematisch versiert sind und plötzlich

**[Video 06:09–06:43](https://www.youtube.com/watch?v=sqll2929L-U&t=369)**

3,14 in Ihrem Code sehen, wissen Sie wahrscheinlich, dass es sich um Pi handelt. Aber wir können ihm eine symbolischere Bedeutung geben, indem wir statt des Werts das Wort Pi verwenden. Während der Kompilierung wird dann jedes Vorkommen von Pi durch 3,14 und so weiter ersetzt. So müssen Sie die lange Zahl nicht jedes Mal tippen, während Ihr Programm trotzdem die erwartete Funktionalität behält.

### Folie 9 — Präprozessor-Direktive #define

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

C bietet die Möglichkeit, mit einer Präprozessor-Direktive (auch Makro genannt) symbolische Konstanten zu erstellen.

```text
#define KURS "Inf-Einf-B"
```

Beim Kompilieren Ihres Programms durchsucht der Kompiler Ihren Code und ersetzt `KURS` durch `"Inf-Einf-B"`.

#include ist also wie Kopieren/Einfügen, #define wie Suchen/Ersetzen.

#### Transkript

**[Video 06:09–06:43](https://www.youtube.com/watch?v=sqll2929L-U&t=369)**

Diese Methode ist nicht auf Zahlen beschränkt. Zum Beispiel könnten wir auch definieren: define KURS Inf-Einf-B. In diesem Fall würde der Compiler bei der Kompilierung jedes Vorkommen von KURS durch den String Inf-Einf-B ersetzen.

**[Video 06:43–07:14](https://www.youtube.com/watch?v=sqll2929L-U&t=403)**

Sie haben sicherlich bemerkt, dass ich alle definierten symbolischen Konstanten in Großbuchstaben schreibe. Das ist eine Konvention, keine Pflicht. Der Grund dafür ist, dass es so deutlich wird, dass es sich um eine definierte Konstante handelt und nicht um eine Variable. Lassen Sie uns nun sehen, wie wir Define in unserem Kartenspielbeispiel anwenden können.

### Folie 10

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

```text
#define DECKSIZE 52

card deal_cards(deck name)
{
    for (int i = 0; i < DECKSIZE; i++)
    {
        // Karte austeilen
    }
}
```

#### Transkript

**[Video 06:43–07:14](https://www.youtube.com/watch?v=sqll2929L-U&t=403)**

Hier ist unsere verbesserte Version der Funktion. Diese Lösung ist deutlich besser als die vorherigen. Indem wir DECKSIZE als 52 definieren, machen wir die Verwendung von 52 in unserem Code viel intuitiver und sicherer.

**[Video 07:14–07:46](https://www.youtube.com/watch?v=sqll2929L-U&t=434)**

Der entscheidende Vorteil hier ist, dass Sie eine Konstante nicht manipulieren können. Sie können nicht sagen DECKSIZE plus plus. Das würde 52 nicht zu 53 machen. DECKSIZE ist und bleibt immer 52. Bei unserer vorherigen Lösung mit einer Variable konnten wir den Wert versehentlich ändern. Hier ist das nicht möglich. 52 ist immer 52 und DECKSIZE ist immer 52. Ein weiterer großer Vorteil dieser Methode ist die Flexibilität, die sie uns bietet. Nicht alle Kartenspiele verwenden ein Deck mit 52 Karten.

**[Video 07:46–08:17](https://www.youtube.com/watch?v=sqll2929L-U&t=466)**

Zum Beispiel gibt es beim Poker 52 Karten, beim Skat 32 und beim Schafkopfen sogar nur 24 Karten. Also, da wo ich herkomme, verwendet man zum Schafkopfen 32 Karten. Ich weiß ja nicht, wo du herkommst, aber in Oberfranken und der Oberpfalz spielt man Schafkopf mit dem kurzen Blatt. Das hat keine Achte und Siebener, also nur 24 Karten. Bei dir spielt man es offenbar mit dem langen Blatt. Aber das ist doch jetzt egal. Wenn wir nun unser Programm für ein anderes Kartenspiel anpassen wollen, müssen wir nur eine einzige Zeile ändern.

**[Video 08:17–08:49](https://www.youtube.com/watch?v=sqll2929L-U&t=497)**

Nämlich die Zeile define DECKSIZE. Wenn wir diese eine Zeile am Anfang unseres Codes ändern und das Programm neu kompilieren, wird die Änderung automatisch überall dort wirksam, wo DECKSIZE verwendet wird.

### Folie 11

[Folie 11 als PDF](https://inf.zone/download/lectures/1-c/1.6-magic-numbers.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

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

**[Video 08:17–08:49](https://www.youtube.com/watch?v=sqll2929L-U&t=497)**

Das spart uns viel Zeit und reduziert die Fehleranfälligkeit erheblich. Das war's auch schon für heute. Ich fasse zusammen, aber das machen wir in den drei Extra Minuten.

### Folie 12 — Beste Lösung: Präprozessor-Direktive #define für symbolische

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

Magic Numbers:

Zahlen im Code ohne klare Bedeutung

Konstanten

Probleme: Beeinträchtigen Lesbarkeit und Wartbarkeit

Vorteile von #define: Klarheit, Unveränderlichkeit

des Codes

und Flexibilität

Erste Verbesserung:

Variablen mit aussagekräftigen

Alternative: const für typsichere, unveränderbare Variablen

Namen

> Bildinhalte sind nicht transkribiert; siehe Originalfolie.

#### Transkript

**[Video 08:17–08:49](https://www.youtube.com/watch?v=sqll2929L-U&t=497)**

Magic Numbers sind hardcodierte Konstanten in unserem Programm, deren Bedeutung nicht sofort ersichtlich ist. Sie können die Wartbarkeit unseres Codes beeinträchtigen, besonders wenn sich Anforderungen ändern.

**[Video 08:49–09:23](https://www.youtube.com/watch?v=sqll2929L-U&t=529)**

Oder der Code von anderen Entwicklern gelesen wird. Eine erste Verbesserung ist die Einführung von Variablen mit aussagekräftigen Namen, aber dies löst nicht alle Probleme, insbesondere wenn es um die versehentliche Änderung von Werten geht. Die beste Lösung, die wir kennengelernt haben, ist die Verwendung von Präprozessordirektiven, insbesondere define. Diese ermöglichen es uns, unveränderliche symbolische Konstanten zu erstellen. Define bietet uns Klarheit, Sicherheit und Flexibilität in unserem Code. Dann sind wir eigentlich fertig, oder? Du, es gibt wieder eine Publikumsfrage. Die sollten wir schon noch beantworten.

### Folie 13

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

„Könnte man nicht auch eine globale Variable verwenden, die mit dem Modifier const als unveränderbar gekennzeichnet wird?“

Ja, das geht.

Hier ein Beispiel:

```javascript
const int max_students = 30;
```

Es gibt Unterschiede im Detail (für uns nicht relevant).

Ob #define oder const verwendet wird, hängt von spezifischen Anforderungen und Präferenzen ab.

#### Transkript

**[Video 09:23–09:55](https://www.youtube.com/watch?v=sqll2929L-U&t=563)**

Und Zeit ist ja auch noch. Aber klar doch. Also die Frage lautet: Könnte man nicht auch eine globale Variable verwenden, die mit dem Modifier const als unveränderbar gekennzeichnet wird? Das ist eine sehr gute Beobachtung. Lass uns das gemeinsam anschauen. Kannst du kurz erklären, was const bedeutet und wie es funktioniert? Das haben wir noch gar nicht behandelt. Gerne. Const ist ein Schlüsselwort in C, das wir verwenden können, um eine Variable als konstant zu deklarieren.

**[Video 09:55–10:28](https://www.youtube.com/watch?v=sqll2929L-U&t=595)**

Das bedeutet, dass ihr Wert nach der Initialisierung nicht mehr geändert werden kann. Hier ein einfaches Beispiel: const int max_students ist gleich 30. In diesem Beispiel ist max_students eine Konstante mit dem Wert 30. Jeder Versuch, diesen Wert zu ändern, würde einen Compilerfehler verursachen. Danke für die Erklärung. Um nun auf die Frage zurückzukommen: Ja, man könnte statt eines Präprozessor-Makros durchaus auch eine globale Variable mit const verwenden, oder? Ja, auf jeden Fall. Auch damit kann man das Problem der Magic Numbers lösen.

**[Video 10:28–11:02](https://www.youtube.com/watch?v=sqll2929L-U&t=628)**

Es würde so aussehen. Dieser Ansatz hat folgende Eigenschaften: Er verhindert versehentliche Änderungen des Wertes. Er gibt dem Wert einen beschreibenden Namen. Außerdem ist der Ansatz typsicher, da DECKSIZE als int deklariert ist. Allerdings gibt es auch einige Unterschiede im Vergleich zu Define. Const-Variablen haben einen Typ und nehmen Speicherplatz ein, während Define eine reine Textersetzung ist. Const-Variablen sind zur Laufzeit verfügbar. Define-Konstanten werden vor der Kompilierung ersetzt. Und: Define ist etwas flexibler, da es für komplexere Makros verwendet werden kann.

**[Video 11:02–11:31](https://www.youtube.com/watch?v=sqll2929L-U&t=662)**

Diese Unterschiede sind für unseren Kurs aber nicht relevant. In der Praxis sind beide Methoden akzeptabel und werden häufig verwendet. Die Wahl zwischen Const und define hängt oft von den spezifischen Anforderungen des Projekts und den Präferenzen des Entwicklerteams ab. So, dann sind wir durch, oder? Ja, sind wir. Aber du musst echt mal lernen, wie man define richtig ausspricht. Aber egal. Nun, da wir die Magie aus unseren Zahlen verbannt haben, wird es Zeit, uns furchteinflößenderen Gegnern zu stellen, oder?

**[Video 11:31–11:57](https://www.youtube.com/watch?v=sqll2929L-U&t=691)**

Furchteinflößender als Magic Numbers? Was könnte das sein? Doch nicht etwa Drachen? Oh nein, viel schlimmer. In unseren nächsten Videos, in unserem nächsten Abenteuer, wagen wir uns vor in die Tiefen von Funktionen und Arrays. Funktionen und Arrays? Das wird sicher anstrengend. Ich fand das heutige Thema eigentlich recht angenehm. Hoffentlich sind die Anforderungen an diese Videos nicht allzu drachonisch.

**[Video 11:57–12:16](https://www.youtube.com/watch?v=sqll2929L-U&t=717)**

Drachenisch? Hilfe, jetzt fängt sie auch noch mit Wortspielen an. Also, schalten Sie beim nächsten Video ein, wenn es heißt: Drachen, Funktionen zähmen leicht gemacht. Dies war Inf-Einf-B.