Funktionen (#109)

* Beispiel für Funktion mit Aufruf

* Kapitel zu Funktionen mit Beispiel versehen

* Apply suggestions from code review

Co-authored-by: Jonas Müller <jonasjmueller@googlemail.com>

Co-authored-by: Felix <felix@elsermail.com>
Co-authored-by: Jonas Müller <jonasjmueller@googlemail.com>

Author: f-elser

basics/funktionen.tex

@@ -1,8 +1,9 @@
 \lesson{Funktionen}
 
-Aus der Mathematik kennt ihr bereits Funktionen, wie zum Beispiel $f(x) = 4x^3 - 8x^2 + 16x - 12$.
-Eine wichtige Idee dahinter ist es einfach $f(3)$ zu schreiben, wenn man eigentlich $4 \cdot 3^3 - 8 \cdot 3^2 + 16 \cdot 3 - 12$ meint.
-Da dies häufig vorteilhaft ist, wurde diese Funktionalität in die meisten Programmiersprachen übernommen.
+Aus der Mathematik kennt ihr bereits Funktionen, wie zum Beispiel $f(x) = x^2$.
+Eine wichtige Idee dahinter ist es, einfach $f(2.5)$ zu schreiben, wenn man eigentlich $2.5^2$ meint.
+In diesem simplen Beispiel bilden wir einfach eine reelle Zahl ab und erhalten als Ergebnis wieder eine reelle Zahl.
+So ähnlich findet sich das Konzept von Funktionen auch in Programmiersprachen wie \Cpp wieder.
 
 Eine Funktion in \Cpp besteht aus zwei Teilen: der \emph{Signatur} und dem \emph{Funktionsrumpf}.
 Die Kombination von Parametertypen und Rückgabetyp bildet die Signatur einer Funktion.
@@ -16,27 +17,41 @@
 \]
 %sorry etwas hässlich
 
-Diese Signatur besteht also aus einem Datentypen, der den Rückgabetypen der Funktion bestimmt, direkt gefolgt von dem Namen der Funktion, der beliebig gewählt werden kann.
-Und dahinter in Klammern werden die einzelnen Paramter durch Komma getrennt angeben, wobei ein Paramter immer aus dem Datentyp des Paramters und einem beliebigen Namen für den Paramter besteht.
+\begin{itemize}
+	\item Rückgabetyp: Bestimmt welchen Datentyp die Rückgabe der Funktion hat
+	\item Name: Ein frei wählbarer Name für die Funktion 
+	\item Parameter: Besteht aus dem Datentype des Parameters und dem beliebig wählbaren Parameternamen. \\Mehrere Parameter können angegeben werden, indem man diese durch Kommata voneinander trennt.
+\end{itemize}
+
 In diesem Fall ist also \texttt{double} der Rückgabewert, \cppinline{my_func} der Name, \cppinline{x} ein Parameter mit dem Typ \texttt{double} und \cppinline{n} ein Paramter mit dem Typ \texttt{int}.
 Damit können dann Werte an die Funktion in der Form \cppinline{my_func(1.41, 2)} übergeben werden.
 
-An dieser Stelle ist der Unterschied zwischen Rückgabe und Ausgabe wichtig: Eine Ausgabe (gekennzeichnet durch \cppinline{std::cout}) gibt Informationen auf dem Bildschirm für die Nutzerin aus, eine Rückgabe (gekennzeichnet durch \texttt{return}) gibt hingegen ein bestimmtes Ergebnis an einen anderen Teil des Programmes zurück, damit dieser dort in einer Variable gespeichert oder direkt weiter verarbeitet werden kann.
+An dieser Stelle ist der Unterschied zwischen Rückgabe und Ausgabe wichtig: Eine Ausgabe (gekennzeichnet durch \cppinline{std::cout}) gibt Informationen auf dem Bildschirm für die Nutzerin aus, eine Rückgabe (gekennzeichnet durch \texttt{return}) gibt hingegen ein bestimmtes Ergebnis an einen anderen Teil des Programms zurück, damit dieser dort in einer Variable gespeichert oder direkt weiter verarbeitet werden kann.
+
+Der Funktionsrumpf beinhaltet den Code, der beim Funktionsaufruf tatsächlich ausgeführt wird.
+Dieser wird wie in einer Schleife von \mintinline{c++}|{| und \mintinline{c++}|}| umschlossen.
+Innerhalb dieser Klammern kann dann beliebiger Code ausgeführt werden, wie auch in der \texttt{main}-Funktion.
+Dabei kann auf die Parameter einfach mit dem in der Signatur definierten Namen zugegriffen werden.
+Also in unserem Beispiel mit \cppinline{x} und \cppinline{n}.
+Vor dem Ende des Funktionsrumpfes muss eine Rückgabe mit \texttt{return} ausgeführt werden.\\
+\newpage
+Eine Funktion, die $ x^n $ berechnet und ein paar mal aufgerufen wird, könnte dann wie folgt aussehen:
+
+\inputcpp{beispielfunktion.cpp}
+
+Unsere Funktion wird in diesem Beispiel 4-mal aufgerufen.
+Das erste mal werden konkrete Werte als Parameter übergeben.\\
+Beim zweiten Aufruf übergeben wir eine Variable, anstelle eines konkreten Werts.\\
+Und dann? In Zeile 14 rufen wir \cppinline{my_func} mit dem Ergebnis eines weiteren Funktionsaufrufs auf, ohne dieses zuerst in einer Variablen zwischenzuspeichern.
 Dabei kann man sich vorstellen, dass der Funktionsaufruf nach dem die Funktion ausgeführt wurde durch den Rückgabewert ersetzt wird.
-Dies könnte für die Funktion \cppinline{my_func} folendermaßen aussehen:
+Dies könnte für die Funktion \cppinline{my_func} folgendermaßen aussehen:
 
 \begin{center}
 	\cppinline{f(5.0 + f(3.0, 2), 3)} $\mapsto$ \cppinline{f(5.0 + 9.0, 3)} $\mapsto$ \cppinline{f(14.0, 3)} $\mapsto$ \cppinline{2744}
 \end{center}
 
 
-Der Funktionsrumpf beinhaltet den Code, der beim Funktionsaufruf tatsächlich ausgeführt wird.
-Dieser wird wie in einer Schleife von \mintinline{c++}|{| und \mintinline{c++}|}| umschlossen.
-Innerhalb dieser Klammern kann dann beliebiger Code ausgeführt werden, wie auch in der \texttt{main}-Funktion.
-Dabei kann auf die Parameter einfach mit dem in der Signatur definierten Namen zugegriffen werden.
-Also in unserem Beispiel mit \cppinline{x} und \cppinline{n}.
-Vor dem Ende des Funktionsrumpfes muss eine Rückgabe mit \texttt{return} ausgeführt werden.
-Das kann zum Beispiel so \texttt{return x;} oder so \texttt{return 5;} aussehen.
+
 
 Funktionen werden beispielsweise benötigt, wenn bestimmte Programmteile häufiger mit verschiedenen Parametern ausgeführt werden sollen.
 Die Collatz-Vermutung\footnote{\url{https://de.wikipedia.org/wiki/Collatz-Vermutung}} besagt für die Folge:

files/beispielfunktion.cpp

@@ -0,0 +1,16 @@
+double my_func(double x, int n) {
+    int ergebnis = x;
+    int i = 1;
+    while (i <= n) {
+	ergebnis = ergebnis * x ;
+        i = i + 1;
+    } 
+    return ergebnis;
+}
+
+int main() {
+    double ergebnis1 = my_func(3.142, 4);
+    double ergebnis2 = my_func(ergebnis1, 2);
+    double ergebnis3 = my_func(5.0 + my_func(3.0, 2), 3);
+    return 0;
+}