# 2.1 Funktionen Quelle: https://inf.zone/lectures/2-arrays/short-2-1-funktionen/ ## Video [Video ansehen](https://oc.streams.uni-bamberg.de/paella7/ui/watch.html?id=62805314-8fa8-4d6b-8714-597916cfc343) ### Alternativen - [Video auf YouTube](https://youtu.be/3v9ZSKPmyKc) - 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 17: In der kürzeren Fassung muss es „return x + y;“ heißen, nicht „return x \* y;“. ## Was davon zur Basis gehört Der Hauptteil dieses Shorts gehört ganz zur Basis. - **Programmieren können** (Basis-Code): Funktionen, Parameter, Rückgabewerte, Scope; Kommentare, Codestil (Einrückung, Klammersetzung, sprechende Namen) - **Erklären und von Hand durchspielen** (Basis-Konzept): Abstraktion, Algorithmusbegriff, Pseudocode - „Die drei Extra-Minuten“ (ab Folie 23): **Basis.** Sie üben und wiederholen den Stoff des Hauptteils. Was die Labels bedeuten, steht unter [Was Sie zum Bestehen können müssen](https://inf.zone/extras/lernen/#was-sie-zum-bestehen-können-müssen). ## Material - [Folien](https://inf.zone/download/lectures/2-arrays/2.1-funktionen.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 — Funktionen [Folie 1 als PDF](https://inf.zone/download/lectures/2-arrays/2.1-funktionen.pdf#page=1) #### Transkript **[Video 00:00–00:31](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=0)** Dies ist Inf-Einf-B. Heute Funktionen. Weißt du, es ist wirklich wichtig, das Publikum von Anfang an zu fesseln. ### Folie 2 [Folie 2 als PDF](https://inf.zone/download/lectures/2-arrays/2.1-funktionen.pdf#page=2) Bis jetzt wurden alle Programme, die wir in diesem Kurs geschrieben haben, innerhalb von `main()` geschrieben. Das war bisher noch kein Problem, aber es könnte eines werden, wenn unsere Programme anfangen, unhandlich zu werden. #### Transkript **[Video 00:00–00:31](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=0)** Eine gute Möglichkeit dafür ist zum Beispiel, an gemeinsame Erfahrungen anzuknüpfen. Ah, ich verstehe. Wie wäre es damit? Erinnert ihr euch an die Zeiten, als wir seitenweise Code in die Main-Funktion gekloppt haben, bis unsere Finger schmerzten und der Bildschirm vor unseren Augen verschwamm? Na ja, fast. Vielleicht etwas weniger dramatisch. Aber du bist schon auf dem richtigen Weg. **[Video 00:31–01:05](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=31)** Alles klar, dann lass es mich noch einmal versuchen. Heute geht es um Funktionen in der Programmierung. Bisher haben wir alle unsere Programme innerhalb der Main-Funktion geschrieben. Das hat uns bisher keine Probleme bereitet, aber es könnte schwierig werden, wenn unsere Programme anfangen, unübersichtlich zu werden. ### Folie 3 [Folie 3 als PDF](https://inf.zone/download/lectures/2-arrays/2.1-funktionen.pdf#page=3) C und fast alle Sprachen, die seitdem entwickelt wurden, erlauben es uns, Funktionen zu schreiben, die manchmal auch als Prozeduren, Methoden oder Unterprogramme bezeichnet werden. #### Transkript **[Video 00:31–01:05](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=31)** C und viele andere Programmiersprachen erlauben uns Funktionen zu schreiben. Diese werden manchmal auch als Prozeduren, Methoden oder Unterprogramme bezeichnet. Perfekt. Das stellt jetzt eine gute Verbindung zu dem her, was wir bisher gemacht haben. Und es führt auch gleich elegant zum neuen Thema über. Was übrigens auch ziemlich gut funktioniert, ist Storytelling. **[Video 01:05–01:36](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=65)** Stimmt. Funktionen sind quasi die Superhelden des Codes. Sie kommen, lösen Probleme und verschwinden wieder, ohne viel Aufhebens zu machen. Oje, weißt du, es muss jetzt nicht immer gleich eine Heldenreise sein. Aber mit diesem Bild im Kopf sind wir auf jeden Fall super vorbereitet, tiefer in die Welt der Funktionen einzutauchen. Also leg mal los. ### Folie 4 — Was ist eine Funktion? [Folie 4 als PDF](https://inf.zone/download/lectures/2-arrays/2.1-funktionen.pdf#page=4) Eine Black-Box mit keinem oder mehreren Eingabewerten und einem Ausgabewert. b a c func(a, b, c) z #### Transkript **[Video 01:05–01:36](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=65)** Lassen Sie uns nun genauer betrachten, was eine Funktion eigentlich ist. Im Wesentlichen kann man sich eine Funktion als eine Blackbox vorstellen. Diese Blackbox hat eine Reihe von Eingaben, wobei die Anzahl der Eingaben auch null sein kann. **[Video 01:36–02:10](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=96)** und genau eine Ausgabe. In der Programmierung sind Funktionen tatsächlich sehr ähnlich zu mathematischen Funktionen. Sie nehmen Werte entgegen, verarbeiten sie und geben ein Ergebnis zurück. Um das Konzept zu veranschaulichen, stellen Sie sich eine Funktion namens func vor, die drei Eingaben a, b und c hat. ### Folie 5 — Was ist eine Funktion? [Folie 5 als PDF](https://inf.zone/download/lectures/2-arrays/2.1-funktionen.pdf#page=5) Eine Black-Box mit keinem oder mehreren Eingabewerten und einem Ausgabewert. b a c add(a, b, c) z #### Transkript **[Video 01:36–02:10](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=96)** Diese Funktion verarbeitet die Eingaben auf irgendeine Weise innerhalb der Blackbox und produziert dann eine einzige Ausgabe, die wir z nennen. Lassen Sie uns das Konzept der Funktion mit einem konkreten Beispiel veranschaulichen. Stellen wir uns eine Funktion namens add vor. Diese Funktion nimmt drei Eingaben a, b und c. **[Video 02:10–02:42](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=130)** Innerhalb der Blackbox verarbeitet die Funktion diese Eingaben auf eine bestimmte Weise. ### Folie 6 — Was ist eine Funktion? [Folie 6 als PDF](https://inf.zone/download/lectures/2-arrays/2.1-funktionen.pdf#page=6) Eine Black-Box mit keinem oder mehreren Eingabewerten und einem Ausgabewert. 6 3 7 add(3, 6, 7) 16 #### Transkript **[Video 02:10–02:42](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=130)** In diesem Fall, wie der Name add schon vermuten lässt, addiert die Funktion die drei Eingabewerte. Wenn wir also die Werte 3, 6 und 7 als Eingabe in diese Funktion geben, erwarten wir als Ausgabe die Summe dieser Zahlen, also 16. Das Schöne daran ist, dass wir uns als Benutzer der Funktion nicht darum kümmern müssen, wie genau die Addition innerhalb der Funktion durchgeführt wird. Wir geben einfach die Werte ein und erhalten das Ergebnis. ### Folie 7 — Was ist eine Funktion ? [Folie 7 als PDF](https://inf.zone/download/lectures/2-arrays/2.1-funktionen.pdf#page=7) Eine Black-Box mit keinem oder mehreren Eingabewerten und einem Ausgabewert. 5 4 mult(4, 5) 20 #### Transkript > Zuordnung unsicher: wenige gemeinsame Textmerkmale; anhand der benachbarten Folien eingeordnet. **[Video 02:10–02:42](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=130)** Lassen Sie uns ein weiteres Beispiel betrachten, um das Konzept der Funktionen noch besser zu verstehen. **[Video 02:42–03:14](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=162)** Hier haben wir eine Funktion namens mult, die dazu dient, zwei Zahlen zu multiplizieren. Diese Funktion nimmt zwei Eingaben, nennen wir sie wieder a und b. In unserem Beispiel geben wir die Werte vier und fünf ein. Die Funktion verarbeitet diese Eingaben, indem sie sie miteinander multipliziert. Als Ergebnis, also als Ausgabe, erhalten wir zwanzig. ### Folie 8 — Warum sagen wir Black-Box? [Folie 8 als PDF](https://inf.zone/download/lectures/2-arrays/2.1-funktionen.pdf#page=8) Wenn wir die Funktionen nicht selbst schreiben, müssen wir die zugrunde liegende Implementierung nicht kennen. ```text mult(a, b): output a * b ``` #### Transkript **[Video 02:42–03:14](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=162)** Dieses Beispiel zeigt, wie Funktionen verwendet werden können, um mathematische Operationen zu kapseln. Statt jedes Mal, wenn wir eine Multiplikation benötigen, den Multiplikationsoperator direkt im Code zu verwenden, können wir einfach diese Funktion aufrufen. **[Video 03:14–03:48](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=194)** Jetzt fragt man sich aber vielleicht, was Funktionen dann überhaupt bringen. Fürs Addieren und Multiplizieren haben wir ja schon Operatoren. Die Studierenden werden noch viele kompliziertere Funktionen schreiben. Zum Verstehen des Konzepts brauchen wir aber etwas ganz Einfaches. Gleich wird es interessant. Okay, mach einfach mal weiter. Nun, warum bezeichnen wir Funktionen als Blackbox? Der Grund dafür ist, dass wir als Benutzer einer Funktion nicht unbedingt wissen müssen, wie sie intern implementiert ist. ### Folie 9 — Warum sagen wir Black-Box? [Folie 9 als PDF](https://inf.zone/download/lectures/2-arrays/2.1-funktionen.pdf#page=9) Wenn wir die Funktionen nicht selbst schreiben, müssen wir die zugrunde liegende Implementierung nicht kennen. ```text mult(a, b): set counter to 0 repeat b times add a to counter output counter ``` #### Transkript **[Video 03:14–03:48](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=194)** Nehmen wir etwa unsere Funktion mult. Eine mögliche Implementierung könnte so aussehen: output equals a times b. **[Video 03:48–04:14](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=228)** Aber es könnte auch ganz anders implementiert sein: Set Counter to 0, Repeat B times, Add A to Counter, Output Counter. Beide Implementierungen führen zum gleichen Ergebnis, aber der interne Prozess ist unterschiedlich. ### Folie 10 — Warum sagen wir Black-Box? [Folie 10 als PDF](https://inf.zone/download/lectures/2-arrays/2.1-funktionen.pdf#page=10) Wenn wir die Funktionen nicht selbst schreiben, müssen wir die zugrunde liegende Implementierung nicht kennen. Funktionen haben idealerweise klare und offensichtliche Namen und sind gut dokumentiert. Ihr Verhalten ist idealerweise vorhersehbar basierend auf dem Namen. Es ist so ähnlich wie bei einem Vertrag, mit dem bestimmte Eigenschaften zugesichert werden: Wenn man eine Funktion schreibt, die andere (oder man selbst) verwenden, geht man davon aus, dass die Funktion sich so verhält, wie man es erwarten würde. #### Transkript **[Video 03:48–04:14](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=228)** Als Benutzer der Funktion ist es für uns nicht wichtig, welche Methode verwendet wird, solange das Ergebnis korrekt ist. Das ist Teil des Vertrags bei der Verwendung von Funktionen. Das Verhalten ist in der Regel vorhersehbar, basierend auf dem Namen **[Video 04:14–04:39](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=254)** der Funktion. Deshalb haben die meisten Funktionen klare und offensichtliche Namen. So. Nachdem wir nun verstanden haben, was Funktionen sind, wollen wir uns ansehen, warum wir sie überhaupt verwenden sollten. ### Folie 11 — Funktionen helfen bei der Abstraktion. [Folie 11 als PDF](https://inf.zone/download/lectures/2-arrays/2.1-funktionen.pdf#page=11) Organisation Funktionen helfen, ein kompliziertes Problem in überschaubare Teilaufgaben zu zerlegen. Vereinfachung Kleinere Komponenten sind in der Regel einfacher zu entwerfen, zu implementieren und zu debuggen. Wiederverwendbarkeit Funktionen können recycelt werden; man muss sie nur einmal schreiben, kann sie aber so oft wie nötig verwenden. #### Transkript **[Video 04:14–04:39](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=254)** Es gibt drei Hauptgründe dafür. Erstens: Organisation. Funktionen helfen uns, ein kompliziertes Problem in überschaubare Teilaufgaben zu zerlegen. Statt einen riesigen Block Code zu haben, können wir ihn in kleinere logische Einheiten aufteilen. Zweitens: Vereinfachung. **[Video 04:39–05:05](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=279)** Kleinere Komponenten sind in der Regel einfacher zu entwerfen, zu implementieren und zu debuggen. Wenn wir ein Problem in einer Funktion haben, müssen wir nur diesen kleinen Teil des Codes überprüfen, nicht das gesamte Programm. Drittens: Wiederverwendbarkeit. Funktionen können recycelt werden. Man muss sie nur einmal schreiben, kann sie aber so oft wie nötig verwenden. Das spart Zeit und reduziert die Fehleranfälligkeit, da wir nicht jedes Mal den gleichen Code neu schreiben müssen. Kommen wir nun zum praktischen Teil. ### Folie 12 [Folie 12 als PDF](https://inf.zone/download/lectures/2-arrays/2.1-funktionen.pdf#page=12) Funktionsdeklarationen Der erste Schritt zur Erstellung einer Funktion ist ihre Deklaration (auch Prototyp genannt). Funktionsprototypen Dadurch bekommt der Compiler einen Hinweis, dass eine Funktion irgendwo im Code vorkommen wird. Funktionsdeklarationen sollten immer am Anfang von Dateien stehen, d.h. vor dem Beginn von `main()`. #### Transkript **[Video 05:05–05:35](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=305)** Wie erstellen wir eigentlich eine Funktion? Der erste Schritt dazu ist die Deklaration. Die Funktionsdeklaration gibt dem Compiler einen Hinweis darauf, dass eine benutzerdefinierte Funktion im Code erscheint. Es ist wie eine Ankündigung: Achtung, hier kommt später eine Funktion. Wichtig ist, dass Funktionsdeklarationen immer am Anfang ihres Codes stehen sollten, noch bevor Sie mit dem Schreiben von main beginnen. Das hilft dem Compiler, Ihren Code besser zu verstehen und zu organisieren. ### Folie 13 — Es gibt eine Standardform für jede Funktionsdeklaration: [Folie 13 als PDF](https://inf.zone/download/lectures/2-arrays/2.1-funktionen.pdf#page=13) ```text rückgabe-typ name(argumentliste); ``` Der Rückgabetyp ist die Art der Variable, die die Funktion ausgeben wird. Der Name gibt an, wie Sie Ihre Funktion nennen möchten. Die Argumentliste ist die durch Kommas getrennte Liste von Eingabewerten für Ihre Funktion, jede mit ihrem Typ und ihrem Namen. Am Ende steht ein Strichpunkt. #### Transkript **[Video 05:05–05:35](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=305)** Es gibt eine Standardform, der jede Funktionsdeklaration folgt. Sie besteht aus drei Hauptteilen: der Rückgabetyp **[Video 05:35–06:00](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=335)** Dies ist die Art der Variable, die die Funktion ausgeben wird. Der Name, so möchten Sie Ihre Funktion nennen. Die Argumentenliste, dies ist die durch Kommas getrennte Liste von Eingaben für Ihre Funktion, wobei jede Eingabe einen Typ und einen Namen hat. Lassen Sie uns nun ein konkretes Beispiel für eine solche Deklaration betrachten. ### Folie 14 — Beispiel 1 [Folie 14 als PDF](https://inf.zone/download/lectures/2-arrays/2.1-funktionen.pdf#page=14) Beispiel 1 Eine Funktion zum Addieren zweier ganzer Zahlen: ```c int add_two_ints(int a, int b); ``` Die Summe von zwei Ganzzahlen wird ebenfalls eine Ganzzahl sein, also ist der Rückgabetyp `int`. Der Name deutet an, dass die Funktion zwei int-Werte addiert. Die Argumentliste enthält zwei durch Kommas getrennte Variablen `a` und `b`, die jeweils den Datentyp `int` haben. Strichpunkt nicht vergessen! #### Transkript **[Video 05:35–06:00](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=335)** Nehmen wir an, wir möchten eine Funktion erstellen, die zwei ganze Zahlen addiert. Die Summe zweier ganzer Zahlen ist ebenfalls eine ganze Zahl. Daher wird unser Rückgabetyp int. **[Video 06:00–06:26](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=360)** Angesichts dessen, was diese Funktion tut, sollten wir ihr einen aussagekräftigen Namen geben. `add_two_ints` wäre hier angemessen. Es gibt zwei Eingaben für diese Funktion und wir müssen jeder von ihnen für die Zwecke der Funktion einen Namen geben. Da wir keine besonderen Informationen über diese Eingaben haben, ist es in Ordnung, ihnen einfache Namen wie a und b zu geben. Somit sieht unsere vollständige Funktionsdeklaration so aus. Diese Deklaration sagt dem Compiler, es wird eine Funktion namens **[Video 06:26–06:53](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=386)** `add_two_ints` geben, die zwei ganze Zahlen als Eingabe nimmt und eine ganze Zahl als Ergebnis zurückgibt. Ah, vielleicht solltest du an der Stelle noch etwas zu den Unterstrichen sagen, die du jetzt im Funktionsnamen verwendest. Für die Studierenden ist das vielleicht ungewohnt. Warum schreibt man nicht einfach einen Bindestrich oder ein Leerzeichen zwischen die Wörter? Dass Funktionen aus Kleinbuchstaben bestehen und die Wörter mit Unterstrichen getrennt werden, ist eine von mehreren Varianten, die in C üblich sind. Es gibt noch andere Varianten, zum Beispiel CamelCase. **[Video 06:53–07:21](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=413)** Da schreibt man am Wortanfang immer einen Großbuchstaben und die Wörter ohne Unterstriche zusammen. ### Folie 15 — Beispiel 2 [Folie 15 als PDF](https://inf.zone/download/lectures/2-arrays/2.1-funktionen.pdf#page=15) Eine Funktion zum Multiplizieren zweier Fließkommazahlen: ```text float mult_two_reals(float a, float b); ``` Das Produkt zweier Fließkommazahlen ist ebenfalls eine Fließkommazahl. Geben wir dem Ganzen einen passenden Namen. Auch hier sind die Namen der Eingabewerte zum Verständnis nicht so wichtig, also können wir kurze und einfache Namen (a, b) verwenden. Alternative mit höherer Genauigkeit ```text double mult_two_reals(double a, double b); ``` #### Transkript **[Video 06:53–07:21](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=413)** Wichtig ist, dass es in C bestimmte Zeichen gibt, die man nicht in Funktionsnamen verwenden darf. Zum Beispiel können wir keine Leerzeichen verwenden. Auch viele Sonderzeichen sind verboten. Vor allem der Bindestrich, der Klammeraffen, die Raute und das Dollarzeichen. Auch dürfen Funktionsnamen nicht mit einer Zahl beginnen. Oh, Schlüsselwörter wie if, while oder return sind auch tabu. Und außerdem muss man beachten: Wart mal. **[Video 07:21–07:46](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=441)** Also, das ist zwar alles total interessant, aber ich glaube, wir müssen uns hier etwas zurückhalten. Du musst mir nicht dauernd beweisen, dass du eh viel mehr weißt als ich. Wahre Größe haben doch die, die nicht einfach alles erzählen, was sie wissen, sondern nur das, was für die Zuhörenden gerade auch wichtig ist. Oh, entschuldige. Du hast völlig recht. Manchmal verliere ich mich halt in den Details. Ab jetzt konzentriere ich mich aber auf das Wichtigste. Das hilft sicher auch beim Zuhören und bis zum Schluss aufmerksam zu bleiben. **[Video 07:46–08:18](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=466)** Genau. Weiter. Lasst uns ein weiteres Beispiel für eine Funktionsdeklaration betrachten. Diesmal wollen wir eine Funktion erstellen, die zwei Fließkomma-Zahlen multipliziert. Das Produkt zweier Fließkomma-Zahlen ist ebenfalls eine Fließkomma-Zahl. Daher verwenden wir hier als Rückgabetyp float. Ein passender Name für diese Funktion wäre `mult_two_reals`. Wieder haben wir zwei Eingaben, die wir einfach x und y nennen können. Unsere Funktionsdeklaration sieht also so aus. Diese Deklaration sagt dem Compiler, es wird eine Funktion namens `mult_two_reals` geben, die zwei Fließkomma-Zahlen als Eingabe nimmt. **[Video 08:18–08:53](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=498)** und eine Fließkommazahl als Ergebnis zurückgibt. Alternativ könnten wir auch den Typ double verwenden, wenn wir eine höhere Genauigkeit benötigen. ### Folie 16 — Funktions- [Folie 16 als PDF](https://inf.zone/download/lectures/2-arrays/2.1-funktionen.pdf#page=16) Der zweite Schritt zur Erstellung einer Funktion ist ihre Definition. Sie beschreibt das Verhalten beim Funktionsaufruf. Die Definition beginnt wie die Deklaration – jetzt aber ohne Strichpunkt! Danach folgt die Implementation: definition ```text float mult_two_reals(float x, float y) { float product = x * y; return product; } ``` oder kürzer ```text float mult_two_reals(float x, float y) { return x * y; } ``` #### Transkript **[Video 08:18–08:53](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=498)** Beide Varianten sind gültig und die Wahl hängt von den spezifischen Anforderungen eures Programms ab. Nachdem wir Funktionsdeklarationen behandelt haben, kommen wir nun zum nächsten Schritt: der Definition von Funktionen. Die Definition sorgt für ein vorhersehbares Verhalten, wenn die Funktion mit Eingaben aufgerufen wird. Die Definition ist sozusagen der Inhalt unserer Blackbox. Die Definition einer Funktion sieht am Anfang fast identisch aus wie eine Deklaration, mit einer kleinen Änderung: Anstelle eines Semikolons am Ende **[Video 08:53–09:28](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=533)** Haben wir geschweifte Klammern, die den Funktionskörper umschließen. Lassen Sie uns versuchen, die Funktion `mult_two_reals` zu definieren, die wir zuvor deklariert haben. Hier ist ein Beispiel, wie die Definition aussehen könnte. In diesem Fall deklarieren wir eine neue Variable vom Typ float namens product und weisen ihr den Wert x mal y zu. Dann geben wir product zurück. Beide Definitionen führen zum gleichen Ergebnis. ### Folie 17 — Übung zu Funktionsdefinitionen [Folie 17 als PDF](https://inf.zone/download/lectures/2-arrays/2.1-funktionen.pdf#page=17) Übung zu Funktionsdefinitionen Definieren Sie die Funktion ```c int add_two_ints(int x, int y); int add_two_ints(int x, int y) { int sum = x + y; return sum; } ``` oder kürzer ```c int add_two_ints(int x, int y) { return x + y; } ``` #### Transkript **[Video 08:53–09:28](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=533)** Die Wahl zwischen ihnen hängt oft von Lesbarkeit und persönlichen Vorlieben ab. Jetzt, wo wir gesehen haben, wie man eine Funktion definiert, wollen wir das Gelernte in einer kleinen Übung anwenden. Lassen Sie uns versuchen, die Funktion `add_two_ints` zu definieren. **[Video 09:28–10:00](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=568)** die wir vorher deklariert haben. Zur Erinnerung: Hier ist unsere Funktionsdeklaration. Nehmen Sie sich einen Moment Zeit und überlegen Sie, wie Sie diese Funktion definieren würden. Was muss im Funktionskörper stehen, damit die Funktion zwei ganze Zahlen addiert und das Ergebnis zurückgibt? Hier ist eine mögliche Lösung. Wir könnten die Funktion auch kürzer schreiben. Beide Versionen sind korrekt und führen zum gleichen Ergebnis. ### Folie 18 — Oder umständlicher: [Folie 18 als PDF](https://inf.zone/download/lectures/2-arrays/2.1-funktionen.pdf#page=18) ```c int add_two_ints(int a, int b) { int sum = 0; if (a > 0) for (int i = 0; i < a; sum++, i++) ; else for (int i = a; i < 0; sum--, i++) ; if (b > 0) for (int i = 0; i < b; sum++, i++) ; else for (int i = b; i < 0; sum--, i++) ; return sum; } ``` #### Transkript > Zuordnung unsicher: wenige gemeinsame Textmerkmale; anhand der benachbarten Folien eingeordnet. **[Video 09:28–10:00](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=568)** Die erste Version zeigt jeden Schritt einzeln, was für Anfänger oft leichter zu verstehen ist. Die zweite Version ist kürzer und eleganter, was erfahrene Programmierer oft bevorzugen. Ja, und natürlich auch erfahrene Programmiererinnen. **[Video 10:00–10:27](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=600)** Aber gute Idee, hier eine Übung einzubauen. ### Folie 19 — Merke: Nur weil es funktioniert, heißt das nicht, dass es gut ist! [Folie 19 als PDF](https://inf.zone/download/lectures/2-arrays/2.1-funktionen.pdf#page=19) KISS-Prinzip: Keep it simple and stupid. #### Transkript **[Video 10:00–10:27](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=600)** Du hast schließlich jetzt echt ganz schön lange am Stück geredet, und es ist ja wichtig, solche aktivierenden Elemente in Vorträge einzubauen, damit die Zuhörenden aufmerksam bleiben. Ja, du bist heute irgendwie so still. Sonst sorgst du immer für Auflockerung. Sag mal, wer bist du eigentlich? Und was hast mit meinem Co-Host gemacht? Ja, nichts natürlich. Mach einfach weiter. Du erklärst das gut. Ich melde mich nur, wenn ich was zu sagen habe. **[Video 10:27–10:53](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=627)** Nun, wir haben gesehen, wie man Funktionen auf einfache und effiziente Weise definiert. Aber manchmal kann man auch auf, sagen wir mal, kreativere Lösungen stoßen. Hier ist eine alternative, etwas unkonventionelle Definition für unsere `add_two_ints`-Funktion. Das ist ein perfektes Beispiel dafür, wie man es nicht machen sollte. Diese Version addiert die Zahlen, indem sie in Schleifen einzelne Einheiten hinzufügt oder abzieht. Es funktioniert zwar, ist aber ineffizient, schwer zu lesen und fehleranfällig. **[Video 10:53–11:22](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=653)** Oh, das erinnert mich an den Spruch "Keep it simple and stupid". Genau. Das KISS-Prinzip ist in der Softwareentwicklung sehr wichtig. Es erinnert uns daran, Code zu schreiben, der leicht zu verstehen, zu warten und zu debuggen ist. ### Folie 20 [Folie 20 als PDF](https://inf.zone/download/lectures/2-arrays/2.1-funktionen.pdf#page=20) Funktions- Um eine Funktion zu verwenden, rufen wir sie in unserem Code auf. aufruf Dabei müssen wir der Funktion passende Argumente übergeben und den Rückgabewert einer Variable des richtigen Typs zuweisen. Schauen wir uns ein Beispiel an. #### Transkript **[Video 10:53–11:22](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=653)** Nachdem wir gelernt haben, wie man Funktionen deklariert und definiert, ist es an der Zeit, sie auch zu benutzen. Dafür verwenden wir Funktionsaufrufe. Um eine Funktion aufzurufen, müssen wir ihr einfach die passenden Argumente übergeben und ihren Rückgabewert einer Variable des richtigen Typs zuweisen. **[Video 11:22–11:52](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=682)** Lassen Sie uns das an einem Beispiel veranschaulichen. In diesem Beispiel kommen zuerst unsere Includes, dann folgt unsere Funktionsdeklaration. In der main-Funktion fragen wir den Benutzer nach Eingaben und dann kommt unser Funktionsaufruf. Beachten Sie, wie wir die Funktion aufrufen. Wir übergeben x und y als Argumente, die beide Integern sind, genau wie in unserer Funktionsdeklaration spezifiziert. Der Rückgabewert wird in der Integervariable z gespeichert. Schließlich geben wir das Ergebnis aus. So verwenden wir also unsere Funktion. **[Video 11:52–12:20](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=712)** Um eine nützliche Berechnung durchzuführen. Zum Abschluss unserer Einführung in Funktionen möchte ich noch ein paar wichtige Punkte erwähnen. Erinnern wir uns an unsere Diskussion über Datentypen. ### Folie 21 [Folie 21 als PDF](https://inf.zone/download/lectures/2-arrays/2.1-funktionen.pdf#page=21) ```c #include #include int add_two_ints(int a, int b); int main(void) { int x = get_int("Geben Sie eine Zahl ein: "); int y = get_int("Geben Sie noch eine Zahl ein: "); int z = add_two_ints(x, y); printf("Die Summe von %i und %i ist %i\n", x, y, z); } ``` #### Transkript *Kein Transkriptabschnitt eindeutig dieser Folie zugeordnet. Möglicherweise eine Aufbau-/Grafikfolie oder eine Abweichung zwischen PDF und Video.* ### Folie 22 — Weitere Hinweise [Folie 22 als PDF](https://inf.zone/download/lectures/2-arrays/2.1-funktionen.pdf#page=22) Funktionen können manchmal keine Eingaben haben. In diesem Fall deklarieren wir die Funktion mit einer void-Argumentenliste: ```c int main(void) ``` Funktionen geben manchmal keinen Wert zurück. In diesem Fall deklarieren wir die Funktion mit einem void-Rückgabetyp: ```c void print_hello(void) { printf("Hallo, Welt!\n"); } ``` #### Transkript **[Video 11:52–12:20](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=712)** Wir haben gelernt, dass Funktionen manchmal keine Eingaben benötigen. In solchen Fällen deklarieren wir die Funktion mit einer leeren Argumentenliste, die wir als void bezeichnen. In manchen Varianten von C kann man das void an dieser Stelle auch weglassen. Hier ist ein Beispiel, das Sie bereits kennen. Die main-Funktion, die haben wir bisher immer so geschrieben. **[Video 12:20–12:47](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=740)** Hier bedeutet void in den Klammern, dass die Funktion keine Argumente erwartet. Andererseits gibt es auch Funktionen, die keinen Wert zurückgeben. In diesem Fall deklarieren wir die Funktion mit einem Rückgabetyp void. Ein Beispiel könnte so aussehen: Diese Funktion nimmt keine Argumente entgegen und gibt auch keinen Wert zurück. Sie führt einfach eine Aktion aus. In diesem Fall eine Nachricht auszugeben. Diese Konzepte erweitern unsere Möglichkeiten bei der Arbeit mit Funktionen und erlauben uns, sie flexibel für verschiedene Zwecke einzusetzen. **[Video 12:47–13:21](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=767)** So, das war unsere Einführung in Funktionen. ### Folie 23 [Folie 23 als PDF](https://inf.zone/download/lectures/2-arrays/2.1-funktionen.pdf#page=23) 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 12:47–13:21](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=767)** Wir haben viel gelernt, von der Deklaration über die Definition bis hin zum Aufruf von Funktionen. Jetzt kommen wir zum Teil die drei Extra Minuten. Zeit wird's, oder? Wie wäre es mit einer Übungsaufgabe zum Starten? Das würde den Studierenden helfen, das Gelernte zu festigen. Eine ausgezeichnete Idee. Lass mich eine passende Aufgabe heraussuchen. ### Folie 24 — Übung [Folie 24 als PDF](https://inf.zone/download/lectures/2-arrays/2.1-funktionen.pdf#page=24) Deklarieren und schreiben Sie eine Funktion `valid_triangle`: Die Funktion nimmt drei reelle Zahlen als Argumente (Seitenlängen eines Dreiecks) entgegen und gibt true oder false zurück. Sie prüft, ob die Längen ein gültiges Dreieck bilden können, d.h.: 1. Alle Seiten müssen eine positive Länge haben. 2. Die Summe zweier Seiten muss größer sein als die Länge der dritten Seite. Beginnen Sie mit dem Prototyp. #### Transkript **[Video 12:47–13:21](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=767)** Hier ist eine Übung, die die wichtigsten Punkte zusammenfasst. Deklarieren und schreiben Sie eine Funktion namens `valid_triangle`, die drei reelle Zahlen als Argumente nimmt. Diese Zahlen repräsentieren die Längen der drei Seiten eines Dreiecks. **[Video 13:21–13:48](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=801)** Die Funktion soll entweder true oder false ausgeben, je nachdem, ob diese drei Längen ein gültiges Dreieck bilden können oder nicht. Beachten Sie dabei folgende Regeln für Dreiecke: Ein Dreieck kann nur Seiten mit positiver Länge haben. Die Summe der Längen von zwei beliebigen Seiten des Dreiecks muss größer sein als die Länge der dritten Seite. Diese Aufgabe wird Ihnen helfen, das Gelernte über Deklarationen und Definitionen anzuwenden. Darüber hinaus brauchen Sie Ihr Wissen über Operatoren und bedingte Anweisungen. **[Video 13:48–14:20](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=828)** Nehmen Sie sich ein paar Minuten Zeit, um diese Funktion zu entwerfen. Denken Sie daran, zuerst die Funktion zu deklarieren und dann zu definieren. Am besten pausieren Sie das Video an dieser Stelle, bevor wir uns eine mögliche Lösung ansehen. Hier ist eine mögliche Lösung für unsere `valid_triangle`-Funktion. Wir beginnen mit der Funktionsdeklaration. Die Funktion nimmt drei Float-Werte als Eingabe und gibt einen Bool-Wert zurück. Der erste Test prüft, ob alle Seiten eine positive Länge haben. Wenn eine der Seiten kleiner oder gleich null ist, geben wir false zurück, da es kein gültiges Dreieck sein kann. Der zweite Test überprüft die Dreiecksungleichung. **[Video 14:20–14:54](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=860)** Die Summe der Längen von zwei beliebigen Seiten muss größer sein als die Länge der dritten Seite. ### Folie 25 [Folie 25 als PDF](https://inf.zone/download/lectures/2-arrays/2.1-funktionen.pdf#page=25) ```text bool valid_triangle(float x, float y, float z) { // Alle Seiten müssen positiv sein. if (x <= 0 || y <= 0 || z <= 0) { return false; } // Die Summe zweier Seiten muss größer sein als die dritte. if ((x + y <= z) || (x + z <= y) || (y + z <= x)) { return false; } // Beide Tests bestanden, also gültiges Dreieck. return true; } ``` #### Transkript **[Video 14:20–14:54](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=860)** Wir prüfen dies für alle drei möglichen Kombinationen. Wenn eine dieser Bedingungen nicht erfüllt ist, geben wir den Bool-Wert False zurück. Wenn wir beide Tests bestanden haben, bedeutet das, dass wir ein gültiges Dreieck haben. In diesem Fall geben wir True zurück. ### Folie 26 [Folie 26 als PDF](https://inf.zone/download/lectures/2-arrays/2.1-funktionen.pdf#page=26) F1: Warum muss eine Funktion oberhalb der main-Funktion deklariert werden? F2: Könnte man eine Funktion auch einfach direkt oberhalb der main-Funktion definieren? Wieso ist dieses Vorgehen nicht üblich? F3: Was passiert, wenn eine Funktion einen int als Argument erwartet, aber ein float übergeben wird? #### Transkript **[Video 14:20–14:54](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=860)** Ich habe noch ein paar Fragen vorbereitet, die man an dieser Stelle haben könnte. Erstens: Warum muss eigentlich eine Funktion oberhalb der Main-Funktion deklariert werden? Kannst du das noch mal kurz erklären? Gerne. Der Compiler liest den Code von oben nach unten. **[Video 14:54–15:21](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=894)** Wenn er im Code irgendwo vor der Funktionsdefinition schon auf einen Funktionsaufruf stößt, muss er bereits wissen, dass diese Funktion existiert und wie sie aufgerufen wird. Durch die Deklaration oberhalb von main stellen wir sicher, dass der Compiler alle nötigen Informationen hat, bevor er auf den ersten Funktionsaufruf trifft. Wunderbar, vielen Dank. Gleich noch eine Anschlussfrage: Könnte man eine Funktion auch einfach direkt oberhalb der main-Funktion definieren? Wieso macht man das nicht? **[Video 15:21–15:54](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=921)** Das ist eine gute Frage. Ja, man könnte die Funktion direkt oberhalb von main definieren. Das würde technisch funktionieren. Es ist jedoch nicht üblich, weil es die Lesbarkeit des Codes beeinträchtigt, besonders bei größeren Programmen. Durch die Trennung von Deklaration und Definition können wir einen besseren Überblick über die verfügbaren Funktionen behalten, ohne uns sofort mit den Details ihrer Implementierung befassen zu müssen. Ja, die nächste Frage ist: Was passiert, wenn eine Funktion einen int als Argument erwartet, aber ein float übergeben wird? Ich denke, es wäre besser, wenn wir die Studierenden die restlichen Fragen selbst beantworten lassen. **[Video 15:54–16:21](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=954)** Das selbstständige Erforschen dieser Fragen wird den Studierenden helfen, ein tieferes Verständnis zu entwickeln. ### Folie 27 — Definition: Implementation des Funktionsverhaltens [Folie 27 als PDF](https://inf.zone/download/lectures/2-arrays/2.1-funktionen.pdf#page=27) Funktionen: Black Box mit optionalen Eingabewerten und einem Rückgabewert Beginnt wie Prototyp, aber ohne Strichpunkt. Vorteile: void: keine Rückgabe oder Organisation, Vereinfachung, Wiederverwendbarkeit keine Parameter ermöglichen Abstraktion Deklaration/Prototyp: KISS: Keep It Simple and Stupid Einfache Implementationen Rückgabetyp, Name, Argumentliste sind zu bevorzugen. steht i.d.R. vor main() > Bildinhalte sind nicht transkribiert; siehe Originalfolie. #### Transkript > Zuordnung unsicher: wenige gemeinsame Textmerkmale; anhand der benachbarten Folien eingeordnet. **[Video 15:54–16:21](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=954)** Es stärkt ihr Selbstvertrauen in ihre Problemlösungsfähigkeiten und fördert ihre Neugierde. Ja klar, stimmt. Es geht hier um Selbstwirksamkeit. Das ist ein wichtiges Konzept, das beim Lernen hilft. Immer wenn man selber Lösungen findet, erhöht das die Motivation und das Vertrauen in die eigenen Fähigkeiten. Das ist entscheidend, damit man über längere Zeit beim Lernen Spaß hat und auch erfolgreich ist. **[Video 16:21–16:55](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=981)** Außerdem fördert Selbstwirksamkeit das kritische Denken, die Fähigkeit, Probleme selber zu lösen, und das sind ja auch nützliche Kompetenzen in der Informatik. Nun, da wir am Ende unserer Reise durch die Welt der Funktionen angekommen sind, fühle ich mich tatsächlich ein bisschen wie die Heldin in einem epischen Abenteuer. Wir haben die Blackbox erobert, die Declarations Drachen gezähmt und sind siegreich aus dem Definitions Dungeon zurückgekehrt. Und wie in jeder guten Geschichte haben wir nicht nur neue Fähigkeiten erworben, sondern auch etwas über uns gelernt, nämlich, dass die wahre Kraft in uns selbst liegt oder halt in den Funktionen, die wir programmieren. **[Video 16:55–17:08](https://www.youtube.com/watch?v=3v9ZSKPmyKc&t=1015)** Eine schöne Zusammenfassung. Ich bin sicher, unsere Studierenden fühlen sich jetzt auch wie die Helden auf ihrer eigenen Coding Odyssee. Dies war Inf-Einf-B.