Funktionenabschnitt voellig neu (#59)

* Funktionenabschnitt voellig neu

* Erklärung der Signatur ausgebaut, Text etwas umstrukturiert

* \cppinline ergänzt

* Funktions Signatur Beispiel in \cppinline getan das es Highlighting
bekommt

* formatierung leicht angepasst das es dem Restlichen codingstyle
entspricht

* Revert "formatierung leicht angepasst das es dem Restlichen codingstyle"

This reverts commit d356b42.

* Fixed mixed spaces/tabs

* Versentliches rückgängig machen rückgängig gemacht

* Funktionsrumpf weiter ausgeführt

* variable umbenannt in main

* inline cpp nicht mehr auskommentiert

* Neues Beispiel, alter Text

* Neues Beispiel

* Altes Beispiel gelöscht

* \bf -> \textbf

* auch *.out und _minted-vorkurs/ ignoriert

* \chapter{...} -> \chapter*{...}

* oft \texttt{...} -> \cppinline{...}

Author: jenuk

.gitignore

@@ -1,7 +1,9 @@
 *.aux
 *.log
 *.toc
+*.out
 vorkurs.pdf
 folien/folien.pdf
 folien/passwort.tex
 folien_abschied/folien.pdf
+_minted-vorkurs/

basics/funktionen.tex

@@ -1,97 +1,84 @@
 \lesson{Funktionen}
 
-Wir haben den Begriff schon ein paarmal genannt und auch, wenn ihr es
-vielleicht nicht gemerkt habt, sie waren schon die ganze Zeit vor eurer Nase:
-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.
 
-Eine Funktion ist im Wesentlichen eine Möglichkeit, eine Folge von Anweisungen
-zu bündeln und isolieren. Wir haben schon einmal ein Programm gesehen, mit dem
-wir testen können, ob eine Zahl eine Primzahl ist, oder nicht. Viele Vorteile
-von Funktionen, lassen sich an diesem Beispiel illustrieren. Stellt euch vor,
-ihr braucht in eurem Programm an vielen Stellen einen solchen Primzahltest. Ihr
-könntet jedes mal den gesamten benötigten Code hinschreiben, aber das wäre doch
-eine Menge Arbeit. Eine Funktion ermöglicht es euch, den Code zum Testen
-auszulagern in eine eigene Funktion z.B. \texttt{istprim}. Immer, wenn ihr dann
-testen wollt, ob eine Zahl \texttt{n} eine Primzahl ist, könnt ihr dann einfach
-schreiben \texttt{istprim(n)} und ruft damit die Funktion auf. Das spart
-Schreibarbeit.
+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.
+Parameter sind Werte, die der Funktion übergeben werden, zum Beispiel das $x$ in $f(x)$.
+Für eine Funktion \cppinline{my_func}, die  $x^n$ berechnen soll, könnte eine Signatur so aussehen:
 
-Stellt euch vor, irgendwann ist euch dann ein Test mittels Probedivision nicht
-mehr schnell genug (weil ihr z.B. immer größere Zahlen testen wollt) und ihr
-wollt auf einen schnelleren Test umsteigen. Ohne Funktionen müsstet ihr jedes
-Vorkommen eines Primzahltests in eurem Code einzeln durch den neuen Test
-ersetzen. Mit Funktionen gibt es genau eine Stelle, an der ihr den Code
-austauschen müsst und all die Stellen, an denen ihr ihn benutzt, übernehmen
-automatisch die neue Implementation.
+\begin{center}
+	\cppinline{double my_func(double x, int n)}
+\end{center}
 
-Zuletzt haben wir in der letzten Lektion einiges über Lesbarkeit von Quellcode
-gelernt. Lesbarkeit erhöht Wartbarkeit und reduziert die Möglichkeiten, Fehler
-zu machen. Was stellt ihr euch lesbarer vor, eine Datei, in der einige tausend
-Zeilen Code stehen, ohne sichtbare Struktur und einfach nur als Folge von
-Anweisungen, oder mehrere kleine Datein, mit beschreibenden, verständlichen
-Namen, in denen jeweils mehrere Fun¡tionen, ebenfalls mit verständlichen Namen
-stehen, das alles schön aufgeteilt nach Themengebiet? Funktionen erhöhen
-Lesbarkeit und helfen, den Code zu strukturieren, was ihn verständlicher macht.
+%Signatur Diagramm von Koebi? Ich kriege nichts schönes hin
 
-Das wohl wichtigste Beispiel für eine Funktion habt ihr bereits kennengelernt:
-Die \texttt{main}-Funktion. Diese spezielle Funktion ist der Eintrittspunkt für
-euer Programm. Der Code der \texttt{main}-Funktion ist der erste, der läuft,
-sobald die \texttt{main} fertig abgearbeitet ist, beendet sich euer Programm.
-Damit haben wir auch schon die Wesentlichen Eckpunkte, wie eine Funktion
-syntaktisch auszusehen hat.
+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.
+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.
 
-Das \texttt{int main()} heißt die \emph{Signatur} der Funktion. Die Signatur
-enthält immer den Datentyp, den die Funktion ausgeben soll (in diesem Fall
-\texttt{int}, also eine ganze Zahl), einen Namen (in diesem Fall der spezielle
-Name \texttt{main}) sowie Parameter, die Eingabewerte (in diesem Fall gibt es
-keine Parameter, wir werden aber gleich sehen, wie eine Funktion auszusehen
-hat, die Parameter entgegennimmt). An die Signatur schließt sich direkt eine
-öffnende geschweifte Klammer, dann kommen alle Anweisungen, aus denen die
-Funktion bestehen soll, dann eine schließende geschweifte Klammer.
+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.
+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:
 
-Um das Ergebnis einer Funktion zurückzugeben, benutzen wir \texttt{return}. Wir
-haben das bereits einmal gesehen, wo wir es benutzt haben, um unser Programm zu
-beenden -- das funktionierte in dem Fall, weil wir uns in der \texttt{main}
-befanden und wie gesagt beendet sich das Programm, sobald die \texttt{main}
-fertig ist. Mit Funktionen könnte ein Programm, was eine Zahl darauf testet,
-eine Primzahl zu sein, so aussehen:
-\inputcpp{funktion.cpp}
+\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:
+\[
+	x_n =
+	\begin{cases}
+		\frac{x_{n-1}}{2} & x_{n-1} \text{ ist gerade} \\
+		3 \cdot x_{n-1} + 1 & x_{n-1} \text{ ist ungerade}
+	\end{cases}
+\]
+dass jeder Startwert $x_1$ aus den natürlichen Zahlen nach endlich vielen Schritten bei der $1$ angelangt.
+Zum Beispiel für den Startwert $x_1 = 42$:
 
-Parameter geben wir also in den Klammern an, jeweils so, wie wenn wir eine
-Variable erstellen würden, mit einem Typ und einem Namen. Wenn wir mehrere
-Parameter brauchen, können wir sie mit Kommata trennen. Dann müssen wir auch,
-wenn wir die Funktion benutzen, die einzelnen Eingaben mit Kommata trennen.
+\[
+    42 \mapsto 21 \mapsto 64 \mapsto 32 \mapsto 16 \mapsto 8 \mapsto 4 \mapsto 2 \mapsto 1 \mapsto 4 \mapsto 2 \mapsto 1 \mapsto \ldots
+\]
+
+Wenn nun die Frage aufkommt was die nächsten Folgenglieder von verschiedenen Zahlen sind, wäre ein möglicher Lösungsweg eine Funktion zu schreiben, die der Nutzerin die nächste Zahl in dieser Folge zurückgibt.
+
+\inputcpp{funktion.cpp}
 
 \textbf{Praxis:}
 \begin{enumerate}
-    \item Schreibt eine Funktion, die einen Parameter vom Typ
-        \texttt{std::string} hat und einen Rückgabewert vom Typ \texttt{int}.
-        Die Funktion soll -- so wie wir es bisher schon in vielen Programmen
-        gemacht haben -- den eingegebenen String (der z.B. die Aufforderung
-        enthält, eine Zahl einzugeben) auf die Konsole ausgeben und einen
-        \texttt{int} von der Nutzerin einlesen. Dieser eingelesene \texttt{int}
-        soll dann von der Funktion zurückgegeben werden.
-        Denkt euch einen sprechenden Namen für diese Funktion aus.
-    \item Passt \texttt{funktion.cpp} so an, dass es eure Funktion benutzt.
-    \item Kompiliert das angepasste Programm und lasst es im debugger Schritt
-        für Schritt durchlaufen. Um die Funktion durchlaufen zu lassen, habt
-        ihr zwei Möglichkeiten: Ihr könnt einen neuen breakpoint in der
-        Funktion erstellen, oder ihr könnt, sobald der debugger euch anzeigt,
-        als nächstes die Funktion aufrufen zu wollen, \texttt{step} statt
-        \texttt{next} aufrufen, sodass er in die Funktion hineinspringt.
+	\item Verändert das Programm in \texttt{funktion.cpp} so, dass es nicht die einzelnen Zahlen \texttt{x1}, \texttt{x2} und \texttt{x3}, sondern die Summe dieser ausgibt.
+%Wirkt wie Kinderkram nicht zum Funktionskapitel, möchte aber nochmal den Unterschied zwischen Ausgabe und Rückgabe dadurch nochmal klarer machen
+	\item Kompiliert das angepasste Programm und lasst es im debugger Schritt für Schritt durchlaufen, setzt dafür wieder einen breakpoint für die \texttt{main}-Funktion.
+	    Sobald der debugger euch anzeigt, als nächstes die Funktion ausführen zu wollen, \texttt{step} statt \texttt{next} aufrufen, sodass der debugger in die Funktion hineinspringt.
+	\item Schreibt eine Funktion (nach der Funktion \texttt{collatz} und vor \texttt{main}), die einen \texttt{int} entgegen nimmt und die Anzahl der Schritte bestimmt bis die Folge bei der 1 angekommen ist und diese als \texttt{int} zurückgibt.
+	    Benutzt dafür die bereits vorhandene Funktion \texttt{collatz}.
+	\item Schreibt euer Programm so um, dass es eine Zahl von der Nutzerin entgegen nimmt und die Anzahl der Schritte ausgibt, bis diese Zahl zu einer 1 wird.
 \end{enumerate}
 
 \textbf{Spiel:}
 \begin{enumerate}
-    \item Vertauscht in \texttt{funktion.cpp} die Funktion \texttt{istprim} mit
-        der Funktion \texttt{main} (verschiebt also die gesamte Funktion
-        \texttt{istprim} an das Ende der Datei). Versucht, die Datei zu
-        kompilieren. Was ist die Fehlermeldung des Compilers?
-    \item Verschiebt die Funktion \texttt{istprim} \emph{in} die
-        \texttt{main}-Funktion (also irgendwo nach der öffnenden geschweiften
-        Klammern, aber vor die dazu gehörige schließende). Versucht, die Datei
-        zu kompilieren. Was ist die Fehlermeldung des Compilers?
-    \item Schaut euch eure bisherigen Lösungen an. Findet ihr noch häufiger
-        Stellen, an denen ihr einzelne Teilprogramme in Funktionen auslagern
-        könnt?
+    \item Was passiert, wenn ihr in einer Funktion den \texttt{return}-Ausdruck vor dem Ende eurer Funktion benutzt?
+    \item Vertauscht in \texttt{funktion.cpp} die Funktion \texttt{collatz} mit der Funktion \texttt{main} (verschiebt also die gesamte Funktion \texttt{collatz} an das Ende der Datei).
+        Versucht, die Datei zu kompilieren.
+        Was ist die Fehlermeldung des Compilers?
+    \item Verschiebt die Funktion \texttt{collatz} \emph{in} die \texttt{main}-Funktion (also irgendwo nach der öffnenden geschweiften Klammern, aber vor die dazu gehörige schließende).
+        Versucht, die Datei zu kompilieren. Was ist die Fehlermeldung des Compilers?
+    \item Implementiert die Funktion, die $x^n$ umsetzt, ignoriert dabei zunächst negative Exponenten. \\
+        (\emph{Tipp:} Die Signatur ist bereits oben gegeben, für den Funktionsrumpf könnten sich Schleifen eignen.)
+    \item Ihr könnt eure Funktion von innerhalb wieder aufrufen. Versucht eure Funktion auf negative Exponenten zu erweitern, indem ihr benutzt, dass gilt $x^{-n} = \frac{1.0}{x^n}$.
+    \item Schaut euch eure bisherigen Lösungen an.
+        Findet ihr noch häufiger Stellen, an denen ihr einzelne Teilprogramme in Funktionen auslagern könnt?
 \end{enumerate}

basics/intro.tex

@@ -1,4 +1,4 @@
-\chapter{Die Basics}
+\chapter*{Die Basics}
 \pagestyle{empty}
 
 Im Ersten Kapitel werden wir die Grundlagen der Programmierung lernen.

basics/warning.tex

@@ -94,13 +94,9 @@
         er sich gleich verhält, aber schneller läuft. \texttt{-O2} würde
         bedeuten, dass relativ stark optimiert wird.
 
-        \texttt{collatz.cpp} enthält ein Programm, um die
-        \emph{Collatz-Vermutung}\footnote{\url{https://de.wikipedia.org/wiki/Collatz-Vermutung}}
-        zu testen. Kompiliert es mit \texttt{g++ -Wall -O2 -o collatz
-        collatz.cpp} (probiert es auch einmal ohne \texttt{-O2} oder ohne
-        \texttt{-Wall}) und schaut euch die resultierende Warning an. Benutzt
-        gegebenenfalls Google, um heraus zu finden, was sie bedeutet und wie
-        ihr sie beheben könnt.
+        \texttt{zaehlen.cpp} enthält ein Programm, um bei einem von der Nutzerin eingegebenen Wort zu zählen, wie oft ein bestimmter Buchstabe (zurzeit \texttt{a} vorkommt).
+        Kompiliert es mit \texttt{g++ -Wall -O2 -o zaehlen zaehlen.cpp} (probiert es auch einmal ohne \texttt{-O2} oder ohne \texttt{-Wall}) und schaut euch die resultierende Warning an.
+        Benutzt gegebenenfalls Google, um heraus zu finden, was sie bedeutet und wie ihr sie beheben könnt.
 \end{enumerate}
 
-\inputcpp{collatz.cpp}
+\inputcpp{zaehlen.cpp}

files/collatz.cpp

@@ -1,32 +1,32 @@
-#include <iostream>
-
-// bool ist ein neuer Datentyp. Ein Boolean kann genau zwei Werte
-// annehmen, „true“ und „false“, repräsentiert also ein einziges
-// Bit, beziehungsweise einen Wahrheitswert. In unserem Fall geben
-// wir true zurück, wenn die Eingabe eine Primzahl ist und false,
-// wenn sie keine ist.
-bool istprim(int n) {
-    int i = 2;
-    while (i < n) {
-        if ((n % i) == 0) {
-            return false;
-        }
-        i = i + 1;
-    }
-    return true;
-}
-
-int main() {
-    int m;
-    std::cout << "Gib eine Zahl ein: ";
-    std::cin >> m;
-
-    // Da istprim einen bool zurück gibt, müssen wir nicht
-    // "istprim(n) == true" schreiben. Diese Schreibweise bedeutet
-    // das Gleiche
-    if (istprim(m)) {
-        std::cout << m << " ist eine Primzahl" << std::endl;
-    } else {
-        std::cout << m << " ist keine Primzahl" << std::endl;
-    }
-}
+#include <iostream>
+
+int collatz(int x) {
+    int erg;
+    
+    if (x % 2 == 0) {
+        erg = x / 2;
+    } else {
+        erg = 3*x + 1;
+    }
+    
+    return erg;
+}
+    
+int main() {
+    int eingabe;
+    
+    std::cout << "Mit welcher Zahl moechtest du starten? ";
+    std::cin >> eingabe;
+    
+    int x1 = collatz(eingabe);
+    int x2 = collatz(x1);
+    int x3 = collatz(x2);
+    //bis hierin haben keine Ausgaben statt gefunden, aber collatz wurde
+    //dreimal aufgerufen. Die Zahlen x1, x2 und x3 sind die naechsten
+    //drei Glieder von x (der von der Nutzerin eingegebenen Zahl) aus
+    //gesehen.
+    
+    //Hier werden der Nutzerin nun die Ergebnisse angezeigt:
+    std::cout << eingabe << " -> " << x1 << " -> "
+        << x2 << " -> " << x3 << std::endl;
+}

files/funktion.cpp

@@ -0,0 +1,29 @@
+#include <iostream>
+#include <string>
+
+int zaehlen(std::string str, char c) {
+    int erg;
+
+    unsigned i = 0;
+    // unsigned funktioniert wie int,
+    // kann allerdings keine negativen
+    // Werte speichern.
+    while (i < str.length()) {
+        if (str[i] == c) {
+            erg = erg + 1;
+        }
+        i = i + 1;
+    }
+
+    return erg;
+}
+
+int main() {
+    std::string wort;
+    
+    std::cout << "Gib ein Wort ein: ";
+    std::cin >> wort;
+
+    std::cout << "In deinem Wort kommt " << zaehlen(wort, 'a')
+        << "-mal der Buchstabe a vor." << std::endl;
+}

files/zaehlen.cpp

@@ -31,11 +31,12 @@
 \newcommand{\lesson}[1]{\section*{#1}\pagestyle{fancy}\addcontentsline{toc}{section}{#1}}
 \renewcommand*\thesection{\arabic{section}}
 
-\titlecontents{chapter}[0pt]{\vspace{1em}\large\bf}{\makebox[60pt][l]{Kapitel \thecontentslabel:}\hspace*{10pt}}{}{\titlerule*[1pc]{ }\contentspage}
+\titlecontents{chapter}[0pt]{\vspace{1em}\large\textbf}{\makebox[60pt][l]{Kapitel \thecontentslabel:}\hspace*{10pt}}{}{\titlerule*[1pc]{ }\contentspage}
 \titlecontents{section}[10pt]{}{\makebox[50pt][l]{Lektion \thecontentslabel:}\hspace*{10pt}}{}{\titlerule*[1pc]{ }\contentspage}
 
 \newcommand{\inputcpp}[1]{\usemintedstyle{vs}\inputminted[label=#1,linenos=true,frame=single]{c++}{files/#1}}
 \newcommand{\inputshell}[1]{\usemintedstyle{vs}\inputminted[label=#1,linenos=true,frame=single]{bash}{files/#1}}
 \newcommand{\cppsect}[3]{\usemintedstyle{vs}\inputminted[label=#1,linenos=true,frame=single,firstline=#2,lastline=#3,firstnumber=#2]{c++}{files/#1}}
+\newcommand{\cppinline}[1]{\usemintedstyle{vs}\mintinline{c++}{#1}}
 
 \newminted{text}{frame=single}