Praxis Umgebung und Spiel Umgebung eingeführt, um Umbrüche zu vermeid…

…en (#106)

basics/arith.tex

@@ -28,51 +28,51 @@
 
 \inputcpp{arith2.cpp}
 
-\textbf{Praxis:}
-\begin{enumerate}
-    \item Was gibt dieses Programm aus? Überlegt es euch zuerst und kompiliert
-        es dann, um es auszuprobieren.
-\end{enumerate}
+\begin{praxis}
+    \begin{enumerate}
+        \item Was gibt dieses Programm aus? Überlegt es euch zuerst und kompiliert
+              es dann, um es auszuprobieren.
+    \end{enumerate}
 
-Obwohl \texttt{a = a + 19} mathematisch überhaupt keinen Sinn ergibt, ist doch
-klar, was passiert, wenn man sich den Quellcode eben nicht als Reihe von
-Aussagen, sondern als Folge von \emph{Anweisungen} vorstellt. Das
-Gleichheitszeichen bedeutet dann nicht, dass beide Seiten gleich sein sollen,
-sondern dass der Wert auf der linken Seite den Wert auf der rechten Seite
-annehmen soll.
+    Obwohl \texttt{a = a + 19} mathematisch überhaupt keinen Sinn ergibt, ist doch
+    klar, was passiert, wenn man sich den Quellcode eben nicht als Reihe von
+    Aussagen, sondern als Folge von \emph{Anweisungen} vorstellt. Das
+    Gleichheitszeichen bedeutet dann nicht, dass beide Seiten gleich sein sollen,
+    sondern dass der Wert auf der linken Seite den Wert auf der rechten Seite
+    annehmen soll.
 
-Wie wir in diesem Beispiel ausserdem sehen, können wir nicht nur Strings
-ausgeben, sondern auch Zahlen. \texttt{std::cout} gibt sie in einer Form aus,
-in der wir etwas damit anfangen können. Genauso können wir auch über
-\texttt{std::cin} Zahlen vom Benutzer entgegen nehmen:
+    Wie wir in diesem Beispiel ausserdem sehen, können wir nicht nur Strings
+    ausgeben, sondern auch Zahlen. \texttt{std::cout} gibt sie in einer Form aus,
+    in der wir etwas damit anfangen können. Genauso können wir auch über
+    \texttt{std::cin} Zahlen vom Benutzer entgegen nehmen:
 
-\inputcpp{arith3.cpp}
+    \inputcpp{arith3.cpp}
 
-Langsam aber sicher tasten wir uns an nützliche Programme heran!
+    Langsam aber sicher tasten wir uns an nützliche Programme heran!
 
-\textbf{Praxis:}
-\begin{enumerate}[resume]
-    \item Schreibt ein Programm, welches von der Nutzerin zwei ganze Zahlen
-        entgegen nimmt und anschließend Summe, Differenz, Produkt und Quotient
-        ausspuckt.
-    \item Was fällt auf, wenn ihr z.B. 19 und 7 eingebt?
-	\item Findet heraus (Google ist euer Freund), wie man in \Cpp Division mit
-		Rest durchführt und gebt diese zusätzlich zu den bisherigen Operationen
-		mit aus\footnote{Falls ihr nicht weiterkommt, hilft euch vielleicht das
-		Stichwort „modulo“ oder „modulo-operator“ weiter.}.
-    \item Was passiert, wenn ihr als zweite Zahl eine 0 eingebt?
-\end{enumerate}
+    \begin{enumerate}[resume]
+        \item Schreibt ein Programm, welches von der Nutzerin zwei ganze Zahlen
+              entgegen nimmt und anschließend Summe, Differenz, Produkt und Quotient
+              ausspuckt.
+        \item Was fällt auf, wenn ihr z.B. 19 und 7 eingebt?
+        \item Findet heraus (Google ist euer Freund), wie man in \Cpp Division mit
+              Rest durchführt und gebt diese zusätzlich zu den bisherigen Operationen
+              mit aus\footnote{Falls ihr nicht weiterkommt, hilft euch vielleicht das
+                  Stichwort „modulo“ oder „modulo-operator“ weiter.}.
+        \item Was passiert, wenn ihr als zweite Zahl eine 0 eingebt?
+    \end{enumerate}
+\end{praxis}
 
-\textbf{Spiel:}
-\begin{enumerate}
-    \item Findet heraus, was die größte positive (und was die kleinste
-        negative) Zahl ist, die ihr in einem \texttt{int} speichern könnt.
-        Faulpelze nutzen Google, Lernbegierige versuchen sie experimentell zu
-        ermitteln. Was passiert, wenn ihr eine größere Zahl eingebt?
-    \item Wir arbeiten bisher nur mit \texttt{int}s für ganze Zahlen. Wenn wir
-        mit gebrochenen Zahlen rechnen wollen brauchen wir den Datentyp
-        \texttt{double}. Schreibt euer Mini Rechenprogramm so um, dass es statt
-        \texttt{int}s nur noch \texttt{double} benutzt und probiert es aus.
-        Achtet darauf, dass es Dezimalpunkte und Dezimalkommata gibt, wenn ihr
-        überraschende Ergebnisse erhaltet.
-\end{enumerate}
+\begin{spiel}
+    \begin{enumerate}
+        \item Findet heraus, was die größte positive (und was die kleinste
+              negative) Zahl ist, die ihr in einem \texttt{int} speichern könnt.
+              Faulpelze nutzen Google, Lernbegierige versuchen sie experimentell zu
+              ermitteln. Was passiert, wenn ihr eine größere Zahl eingebt?
+        \item Wir arbeiten bisher nur mit \texttt{int}s für ganze Zahlen. Wenn  wir mit gebrochenen Zahlen rechnen wollen brauchen wir den Datentyp
+              \texttt{double}. Schreibt euer Mini Rechenprogramm so um, dass es statt
+              \texttt{int}s nur noch \texttt{double} benutzt und probiert es aus.
+              Achtet darauf, dass es Dezimalpunkte und Dezimalkommata gibt, wenn ihr
+              überraschende Ergebnisse erhaltet.
+    \end{enumerate}
+\end{spiel}

basics/fehler.tex

@@ -23,9 +23,9 @@
 Wenn wir versuchen, dieses zu kompilieren, gibt uns \texttt{g++} folgendes aus:
 
 \begin{textcode*}{label=g++ -o fehler1 fehler1.cpp}
-fehler1.cpp: In function 'int main()':
-fehler1.cpp:2:5: error: 'cout' is not a member of 'std'
-fehler1.cpp:2:35: error: 'endl' is not a member of 'std'
+    fehler1.cpp: In function 'int main()':
+    fehler1.cpp:2:5: error: 'cout' is not a member of 'std'
+    fehler1.cpp:2:35: error: 'endl' is not a member of 'std'
 \end{textcode*}
 
 Wenn wir diese Fehlermeldung verstehen wollen, fangen wir immer ganz oben an,
@@ -56,8 +56,8 @@
 entgegengespuckt:
 
 \begin{textcode*}{label=g++ -o fehler2 fehler2.cpp}
-fehler2.cpp: In function 'int main()':
-fehler2.cpp:5:1: error: expected ';' before '}' token
+    fehler2.cpp: In function 'int main()':
+    fehler2.cpp:5:1: error: expected ';' before '}' token
 \end{textcode*}
 
 Wiederum sagt uns die erste Zeile, in welcher Datei und Funktion der Fehler
@@ -78,28 +78,31 @@
 sein sollte, schaut vielleicht mal ein oder zwei Zeilen darüber, vielleicht
 wusste der Compiler es einfach nicht besser.
 
-\textbf{Praxis:}
-\begin{enumerate}
-    \item Versucht, folgende Dateien zu kompilieren und schaut euch die
-        Fehlermeldung an. In welcher Zeile, in welcher Spalte liegt der Fehler?
-        Was gibt euch der Compiler als Fehlermeldung aus?
-    \item Versucht, die aufgetretenen Fehler zu korrigieren. Bekommt ihr es
-        hin, dass der Compiler sich nicht mehr beschwert und das Programm
-        korrekt arbeitet (schaut euch ggf. die bisher gezeigten Quellcodes an)?
-\end{enumerate}
-
-\inputcpp{fehler3.cpp}
-\inputcpp{fehler4.cpp}
-
-\textbf{Spiel:}
-\begin{enumerate}
-    \item Das folgende Programm enthält mehrere Fehler. Bekommt ihr trotzdem
-        raus, welche das sind und könnt ihr sie beheben (Tipp: „c++ math“ zu
-        \href{http://lmgtfy.com/?q=c\%2B\%2B+math}{googlen} kann euch hier vielleicht weiter bringen)?
-    \item Wenn ihr in den Vergangen Lektionen ein bisschen gespielt habt und
-        vereinzelnd versucht habt, Dinge zu löschen, Werden euch viele
-        Fehlermeldungen begegnet sein, versucht, diese zu lesen und
-        interpretieren, was euch der compiler hier sagen will.
-\end{enumerate}
-
-\inputcpp{fehler5.cpp}
+\begin{praxis}
+    \begin{enumerate}
+        \item Versucht, folgende Dateien zu kompilieren und schaut euch die
+              Fehlermeldung an. In welcher Zeile, in welcher Spalte liegt der Fehler?
+              Was gibt euch der Compiler als Fehlermeldung aus?
+        \item Versucht, die aufgetretenen Fehler zu korrigieren. Bekommt ihr es
+              hin, dass der Compiler sich nicht mehr beschwert und das Programm
+              korrekt arbeitet (schaut euch ggf. die bisher gezeigten Quellcodes an)?
+    \end{enumerate}
+
+    \inputcpp{fehler3.cpp}
+
+    \inputcpp{fehler4.cpp}
+\end{praxis}
+
+\begin{spiel}
+    \begin{enumerate}
+        \item Das folgende Programm enthält mehrere Fehler. Bekommt ihr trotzdem
+              raus, welche das sind und könnt ihr sie beheben (Tipp: „c++ math“ zu
+              \href{http://lmgtfy.com/?q=c\%2B\%2B+math}{googlen} kann euch hier vielleicht weiter bringen)?
+        \item Wenn ihr in den Vergangen Lektionen ein bisschen gespielt habt und
+              vereinzelnd versucht habt, Dinge zu löschen, Werden euch viele
+              Fehlermeldungen begegnet sein, versucht, diese zu lesen und
+              interpretieren, was euch der compiler hier sagen will.
+    \end{enumerate}
+
+    \inputcpp{fehler5.cpp}
+\end{spiel}

basics/funktionen.tex

@@ -11,7 +11,7 @@
 \[
 	\smashoperator{\mathop{\underbrace{\text{\cppinline{double}}}}_{\text{Rückgabetyp}}}\quad
 	\smashoperator{\mathop{\overbrace{\text{\cppinline{my_func}}}}^{\text{Name}}}
-	(\smashoperator{\mathop{\underbrace{\text{\cppinline{double x}}}}_{\text{Paramter 1}}},\ 
+	(\smashoperator{\mathop{\underbrace{\text{\cppinline{double x}}}}_{\text{Paramter 1}}},\
 	\smashoperator{\mathop{\overbrace{\text{\cppinline{int n}}}^{\text{Paramter 2}}}})
 \]
 %sorry etwas hässlich
@@ -43,46 +43,48 @@
 \[
 	x_n =
 	\begin{cases}
-		\frac{x_{n-1}}{2} & x_{n-1} \text{ ist gerade} \\
+		\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$:
 
 \[
-    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
+	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:}\footnote{In dieser Lektion gibt es ein paar mehr Aufgaben als in anderen Lektionen, lasst euch davon nicht entmutigen!}
-\begin{enumerate}
-	\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 die ein \texttt{double} entgegen nimmt und das Quadrat davon zurück gibt.
-	(Hierbei sollt ihr keine Pakete wie \texttt{math.h} oder \texttt{cmath} benutzen.)
-\end{enumerate}
+\begin{praxis}\footnote{In dieser Lektion gibt es ein paar mehr Aufgaben als in anderen Lektionen, lasst euch davon nicht entmutigen!}
+	\begin{enumerate}
+		\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 die ein \texttt{double} entgegen nimmt und das Quadrat davon zurück gibt.
+		      (Hierbei sollt ihr keine Pakete wie \texttt{math.h} oder \texttt{cmath} benutzen.)
+	\end{enumerate}
+\end{praxis}
 
-\textbf{Spiel:}
-\begin{enumerate}
-	\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.
-	(Die Funktion sollte also die Signatur \cppinline{int schritte(int x)} haben.)
-	Probiert die Funktion aus.
-	\item Versucht jetzt zwei Zahlen von der Nutzerin entgegen zu nehmen und vergleicht mithilfe von der gerade geschriebenen Funktion, welche Zahl mehr Schritte bis zur 1 braucht.
-    \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. \\
-        (Wie in Praxis 3, sollt ihr auch hier keine vorgefertigten Pakete benutzen. \emph{Tipp:} Die Signatur ist bereits oben gegeben, für den Funktionsrumpf könnten sich Schleifen eignen.)
-    \item Eure Funktion kann sich auch selbst aufrufen. Versucht damit eure Funktion auf negative Exponenten zu erweitern, indem ihr benutzt, dass gilt $x^{-n} = \Bigl(\frac{1.0}{x}\Bigr)^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}
+\begin{spiel}
+	\begin{enumerate}
+		\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.
+		      (Die Funktion sollte also die Signatur \cppinline{int schritte(int x)} haben.)
+		      Probiert die Funktion aus.
+		\item Versucht jetzt zwei Zahlen von der Nutzerin entgegen zu nehmen und vergleicht mithilfe von der gerade geschriebenen Funktion, welche Zahl mehr Schritte bis zur 1 braucht.
+		\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. \\
+		      (Wie in Praxis 3, sollt ihr auch hier keine vorgefertigten Pakete benutzen. \emph{Tipp:} Die Signatur ist bereits oben gegeben, für den Funktionsrumpf könnten sich Schleifen eignen.)
+		\item Eure Funktion kann sich auch selbst aufrufen. Versucht damit eure Funktion auf negative Exponenten zu erweitern, indem ihr benutzt, dass gilt $x^{-n} = \Bigl(\frac{1.0}{x}\Bigr)^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}
+\end{spiel}

basics/gdb.tex

@@ -42,34 +42,37 @@
 \end{minted}
 (Beachtet, dass im ersten Parameter erst ein großer Buchstabe o, dann eine 0 stehen)
 \inputcpp{debugger.cpp}
-\textbf{Praxis:}
-\begin{enumerate}
-    \item Kompiliert das Programm mit den neuen Optionen für den debugger. Ihr
-        könnt es dann mittels \verb|gdb ./debugger| im gdb starten. Ihr solltet
-        nun ein wenig Text ausgegeben bekommen und einen anderen prompt
-        (\texttt{(gdb)}). Ihr könnt den debugger jederzeit wieder verlassen,
-        indem ihr \texttt{quit} eingebt (falls ihr gefragt werdet, ob ihr euch
-        sicher seid, gebt \texttt{y} ein und drückt enter)
-    \item Zu allererst müssen wir einen so genannten \emph{breakpoint} setzen,
-        das ist ein Punkt im Programmablauf, an dem es stoppen soll, damit wir
-        entscheiden können, was wir tun wollen. \texttt{main} ist für die
-        meisten unserer Programme eine sichere Wahl:
-        \mint{text}|break main|
-        Dann können wir das Programm mit \texttt{run} starten. Wir sollten die
-        erste Anweisung unseres Programmes angezeigt bekommen.
-    \item Der Debugger wird euch jetzt immer sagen, welches die nächste
-        Anweisung ist, die er ausführen möchte. Mit \texttt{next} könnt ihr sie
-        ausführen lassen, mit \texttt{print a} könnt ihr euch den Inhalt von
-        \texttt{a} zu diesem Zeitpunkt anschauen, mit \texttt{print b} den von
-        \texttt{b} und so weiter. Geht das Programm Schritt für Schritt durch
-        und lasst euch die Werte von \texttt{a}, \texttt{b} und \texttt{c} in
-        jedem Schritt ausgeben. Wenn der debugger euch sagt, dass euer Programm
-        beendet wurde, gebt \texttt{quit} ein und beendet ihn.
-\end{enumerate}
 
-\textbf{Spiel:}
-\begin{enumerate}
-    \item Ihr habt nun schon einige Programme kennen gelernt. Kompiliert sie
-        für den Debugger neu und untersucht sie genauso wie obiges Programm,
-        solange ihr Lust habt.
-\end{enumerate}
+\begin{praxis}
+    \begin{enumerate}
+        \item Kompiliert das Programm mit den neuen Optionen für den debugger. Ihr
+              könnt es dann mittels \verb|gdb ./debugger| im gdb starten. Ihr solltet
+              nun ein wenig Text ausgegeben bekommen und einen anderen prompt
+              (\texttt{(gdb)}). Ihr könnt den debugger jederzeit wieder verlassen,
+              indem ihr \texttt{quit} eingebt (falls ihr gefragt werdet, ob ihr euch
+              sicher seid, gebt \texttt{y} ein und drückt enter)
+        \item Zu allererst müssen wir einen so genannten \emph{breakpoint} setzen,
+              das ist ein Punkt im Programmablauf, an dem es stoppen soll, damit wir
+              entscheiden können, was wir tun wollen. \texttt{main} ist für die
+              meisten unserer Programme eine sichere Wahl:
+              \mint{text}|break main|
+              Dann können wir das Programm mit \texttt{run} starten. Wir sollten die
+              erste Anweisung unseres Programmes angezeigt bekommen.
+        \item Der Debugger wird euch jetzt immer sagen, welches die nächste
+              Anweisung ist, die er ausführen möchte. Mit \texttt{next} könnt ihr sie
+              ausführen lassen, mit \texttt{print a} könnt ihr euch den Inhalt von
+              \texttt{a} zu diesem Zeitpunkt anschauen, mit \texttt{print b} den von
+              \texttt{b} und so weiter. Geht das Programm Schritt für Schritt durch
+              und lasst euch die Werte von \texttt{a}, \texttt{b} und \texttt{c} in
+              jedem Schritt ausgeben. Wenn der debugger euch sagt, dass euer Programm
+              beendet wurde, gebt \texttt{quit} ein und beendet ihn.
+    \end{enumerate}
+\end{praxis}
+
+\begin{spiel}
+    \begin{enumerate}
+        \item Ihr habt nun schon einige Programme kennen gelernt. Kompiliert sie
+              für den Debugger neu und untersucht sie genauso wie obiges Programm,
+              solange ihr Lust habt.
+    \end{enumerate}
+\end{spiel}