diff --git a/Semester_2/Einheit_10/Grundlagen-Python-to-C++.ipynb b/Semester_2/Einheit_10/Grundlagen-Python-to-C++.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..18e6b9571022312a1ef1ceced5299e5e7b07fcc4
--- /dev/null
+++ b/Semester_2/Einheit_10/Grundlagen-Python-to-C++.ipynb
@@ -0,0 +1,614 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "f0b13807-b3b2-4f55-9581-9f8d4ffaa3b5",
+   "metadata": {},
+   "source": [
+    "## <font color='blue'>**Grundlagen beim Schritt von Python zu C++**</font>\n",
+    "\n",
+    "Python ist eine schöne Programmiersprache und viele Aufgaben können damit effizient bearbeitet werden. Dennoch gibt es viele verschiedene Programmiersprachen, die in der Softwareentwicklung verwendet werden.\n",
+    "Jede Sprache hat ihre eigenen Stärken und Schwächen und beim Arbeiten mit verschiedenen Softwaretools muss man sich an die Programmierung in verschiedenen Sprachen gewöhnen.\n",
+    "\n",
+    "C++ gehört zu den am weitesten verbreiteten Sprachen in der IT-Branche. Als objektorientierte Sprachen haben Python und C++ viele Gemeinsamkeiten. Aber es gibt auch erhebliche Unterschiede zwischen den beiden Sprachen.\n",
+    "\n",
+    "### <font color='blue'>**Komfort gegenüber Effizienz**</font>\n",
+    "\n",
+    "Für die CPU direkt ausführbar ist die **Maschinensprache**, in der prinzipiell auch Software entwickelt werden kann. Dies erfolgt insbesondere, wenn die **Ausführungsgeschwindigkeit** eine Rolle spielt. Auf der anderen Seite ist die Entwicklung von Software direkt in Maschinensprache unbequem und für komplexere Systeme indiskutabel. \n",
+    "Für diese Zwecke sind **Hochsprachen** zur Programmierung entwickelt worden, die einen hohen Abstraktionsgrad unterstützen und die \n",
+    "\n",
+    "* **Entwicklungszeit** von Softwaresystemen erheblich verkürzen, \n",
+    "* sehr gute Möglichkeiten zur **Wiederverwendbarkeit** bieten und die \n",
+    "* **Zuverlässigkeit** und **Wartungsfreundlichkeit** von Software insgesamt verbessern. \n",
+    "\n",
+    "Hochsprachen unterstützen eine **größere Anzahl von Datentypen** und eine **reichhaltige Syntax** zur Beschreibung von Operationen. Am Ende muss die Hochsprachenprogrammierung in die Maschinensprache der CPU übersetzt werden, um auf einem Computer ausgeführt werden zu können.\n",
+    "Für Hochsprachen ist diese **Übersetzung** in Form eines **Compilers** oder **Interpreters** automatisiert. \n",
+    "Die Software, die in einer Hochsprache geschrieben wurde, ist daher nicht leistungsfähiger als eine, \n",
+    "die direkt in der Maschinensprache geschrieben bzw. codiert ist.  \n",
+    "Der Komfort, den eine Hochsprache Hochsprache bietet, geht oft auf Kosten kleiner Leistungseinbußen bei der resultierenden Software. Die automatische Übersetzung von Hochsprache in Maschinensprache ist zwar sorgfältig optimiert, aber dennoch ist der generierte Maschinen-Code nicht immer so schlank wie ein Code, der direkt von einem Experten programmiert werden würde.\n",
+    "\n",
+    "Zwar gibt es kleine **Effizienz-Unterschiede**, doch diese werden schnell z.B. durch Leistungssteigerungen der Hardware, Netzwerken kompensiert. Ein größeres Problem ist die **Softwareentwicklungszeit**, d. h. die Zeit, die benötigt wird, um eine Idee von der ersten Inspiration bis zur fertigen Software für den Verbraucher zu verwirklichen. Der **Entwurf** und die **Entwicklung von Softwareanwendungen hoher Qualität** ist extrem arbeitsintensiv und kann je nach Projekt Monate oder Jahre in Anspruch nehmen. Der größte **Kostenfaktor** eines Softwareprojekts ist die Beschäftigung der Entwickler. Daher ist die Verwendung einer Hochsprache von großem Nutzen, um die Abstraktionen besser zu unterstützen und dadurch den gesamten Entwicklungszyklus verkürzen kann.\n",
+    "\n",
+    "<div>\n",
+    "<img src=\"./Pics/Sprachen.png\" width=\"600\"/>\n",
+    "</div>\n",
+    "\n",
+    "Im Laufe der Zeit sind mehr als **tausend Hochsprachen** entwickelt worden, von denen vielleicht hundert noch aktiv für die Programmentwicklung verwendet werden. Was jede Sprache einzigartig macht, ist die Art und Weise, in der Konzepte abstrahiert und ausgedrückt werden. Keine einzige Sprache ist perfekt, und jede versucht auf ihre eigene Art und Weise, die Entwicklung effizienter, wartbarer und wiederverwendbarer Software zu unterstützen. \n",
+    "Hier im Fokus steht das **objektorientierte Paradigma** als ein Beispiel für eine Abstraktion innerhalb der Programmentwicklung.\n",
+    "Selbst innerhalb des objektorientierten Rahmens gibt es Unterschiede zwischen den Sprachen. Im weiteren Verlauf werden wir die wichtigsten Unterschiede zwischen Python und C++ betrachten.\n",
+    "\n",
+    "### <font color='blue'>**Compiler gegenüber Interpreter**</font>\n",
+    "\n",
+    "Ein wichtiger Aspekt jeder Hochsprache ist der Prozess, mit dem sie in den auszuführenden Maschinencode übersetzt wird.\n",
+    "\n",
+    "Python ist ein Beispiel für eine **interpretierte Sprache**. Wir \"starten\" ein typisches Python Programm, indem wir seinen Quellcode als Eingabe in eine andere Software, den Python-**Interpreter**, eingeben.\n",
+    "Der Python-Interpreter ist die Software, die tatsächlich auf der CPU ausgeführt wird. \n",
+    "Er passt sein äußeres Verhalten an die durch den gegebenen Quellcode vorgegebene Semantik an. \n",
+    "Die Übersetzung vom Hochsprachen-Code in Maschinen-Operationen bei jeder Ausführung des Programms **on-the-fly** durchgeführt.\n",
+    "\n",
+    "<div>\n",
+    "<img src=\"./Pics/Interpreter.png\" width=\"800\"/>\n",
+    "</div>\n",
+    "\n",
+    "Im Gegensatz dazu ist C++ ein Beispiel für eine **kompilierte Sprache**. \n",
+    "Der Übergang vom ursprünglichen Quellcode zu einem laufenden Programm ist ein zweistufiger Prozess. \n",
+    "In der **ersten Phase - Kompilierzeit -** ist der Quellcode die Eingabe in eine spezielle Software, dem **sogenannten Compiler**. Dieser Compiler analysiert den Quellcode auf der Grundlage der Syntax der Sprache. Wenn es Syntaxfehler gibt, werden diese gemeldet und die Kompilierung schlägt fehl. Andernfalls übersetzt der Compiler den Hochsprachen-Code in Maschinencode und erzeugt eine Datei, die als ausführbar bezeichnet wird. In der **zweiten Phase - Laufzeit -** wird die ausführbare Datei gestartet. Der Compiler wird dafür nicht mehr benötigt.\n",
+    "\n",
+    "<div>\n",
+    "<img src=\"./Pics/Compiler.png\" width=\"800\"/>\n",
+    "</div>\n",
+    "\n",
+    "Der größte Vorteil des **Kompilier-Modells** ist die **Ausführungsgeschwindigkeit**. Je mehr zur Kompilierungszeit erledigt werden kann, desto weniger Arbeit muss zur Laufzeit erledigt werden. Durch die vollständige Übersetzung in Maschinencode im Voraus wird die Ausführung der Software gestrafft, so dass zur Laufzeit nur noch die Berechnungen durchgeführt werden, die zur Softwareanwendung gehören. \n",
+    "Ein zweiter Vorteil ist, dass die ausführbare Software (**Executable**) als eigenständige **Software an Kunden** verteilt werden kann. \n",
+    "Solange sie für den speziellen Maschinencode ihres Systems entwickelt wurde, kann sie vom Anwendern ausgeführt werden, ohne dass weitere **Softwareinstallationen** (z. B. Interpreter) ausgeführt werden müssen. \n",
+    "Eine Folge dieses Modells ist, dass der Maschinencode von einem Unternehmen vertrieben werden kann, ohne dass der ursprüngliche Quellcode, mit dem er erzeugt wurde, offengelegt wird.\n",
+    "\n",
+    "Im Gegensatz dazu gibt es bei einem rein interpretierten Programm keine Unterscheidung zwischen Kompilierzeit und Laufzeit.\n",
+    "Der Interpreter trägt die Last der **Übersetzung des ursprünglichen Quellcodes als Teil des Laufzeitprozesses**.\n",
+    "Außerdem ist die **Weitergabe** des Quellcodes nur für einen Kunden sinnvoll, der einen kompatiblen Interpreter auf seinem System installiert hat. \n",
+    "Der Hauptvorteil einer interpretierten Sprache ist die größere **Plattform-Unabhängigkeit**. Derselbe Quellcode kann zur Verwendung auf verschiedenen Computerplattformen verteilt werden, solange jede Plattform über einen entsprechenden Interpreter verfügt. \n",
+    "Im Gegensatz dazu ist eine kompilierte ausführbare Datei auf eine bestimmte Maschinensprache zugeschnitten. Verschiedene Versionen der ausführbaren Datei müssen für die Verwendung auf verschiedenen Computerplattformen erstellt und verteilt werden.\n",
+    "\n",
+    "Für Softwareentwickler ist das **Debugging** im Vergleich einer Interpretersprache mit einer zu kompilierenden Sprache von Bedeutung. Wir haben den Interpreter von Python nicht nur zum Ausführen eines Programms verwendet, sondern auch um nützliches **Feedback** und **Interaktionsmöglichkeiten** zu erhalten, wenn Probleme auftreten.\n",
+    "Der Compiler kann bei der Erkennung rein syntaktischer Fehler zur Kompilierzeit hilfreich sein, aber er ist nicht mehr von Nutzen, wenn Laufzeitfehler auftreten.\n",
+    "\n",
+    "\n",
+    "\n",
+    "### <font color='blue'>**Dynamische gegenüber statische Typisierung**</font>\n",
+    "\n",
+    "Bei Compilier-Sprachen wird versucht, so viel Arbeit wie möglich zur Kompilierzeit zu erledigen, um den Laufzeitprozess möglichst effizient zu gestalten. \n",
+    "Diese Umstand ist der größte Unterschied zwischen Python und C++. \n",
+    "Python ist als eine **dynamisch typisierte Sprache**, d.h. zur Laufzeit wird entschieden, welcher Datentyp verwendet wird. Einer Variable kann innerhalb eines Programmbereichs mit einer Zuweisungsanweisung ein Wert zugewiesen werden. Im Beispiel wird die Zahl 42 zugewiesen und wir gehen davon aus, das der wir einen Integer-Datentyp vorliegen haben. Im folgenden können wir eine Zeichenkette der Variablen zuweisen: \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5a8522e1-c1b9-4a66-8cc0-7adc8db083c9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "alter = 42 \n",
+    "alter = 'zweiundvierzig'\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5a598c8b-e133-45bd-b97f-7735e01fecf2",
+   "metadata": {},
+   "source": [
+    "Datentypen sind nicht formal mit den Bezeichnern verbunden, sondern mit den zugrunde liegenden Objekten (daher weiß der Wert 42, dass er eine Ganzzahl ist). Wenn Bezeichner in Ausdrücken verwendet werden, hängt die Zulässigkeit von der Art des zugrunde liegenden Objekts ab.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "0918b8cf-67da-46e4-9825-2744d6c6cc75",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'ZWEIUNDVIERZIG'"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "alter = 42 + 1\n",
+    "alter = 'zweiundvierzig'\n",
+    "alter.upper()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8a6d417f-039c-45c6-8a65-5df9c7b6cd96",
+   "metadata": {},
+   "source": [
+    "In Python werden diese Ausdrücke zur Laufzeit ausgewertet. Wenn der Interpreter auf einen Ausdruck wie `alter.upper( )` stößt, prüft er, ob das Objekt, das derzeit mit dem Namen `alter` verbunden ist, die Syntax `upper( )` unterstützt. Wenn ja, wird der Ausdruck erfolgreich ausgewertet; wenn nicht, tritt ein Laufzeitfehler auf. \n",
+    "Das gleiche Prinzip der dynamischen Typisierung gilt für die **Deklaration von Funktionen**. Die Formalparameter in der Signatur dienen als Platzhalter für die benötigte Anzahl von Aktualparametern, wobei es keine explizite Typisierung gibt. \n",
+    "Die Bezeichner werden den vom Aufrufer gesendeten Objekten zugewiesen. Die dynamische Typisierung gilt auch für die Attribute innerhalb einer Klassendefinition, die im Allgemeinen im Konstruktor initialisiert, aber nie explizit deklariert werden.\n",
+    "\n",
+    "Im Allgemeinen funktioniert der Code so lange, wie die Objekte die erwarteten **Methoden** unterstützen. Andernfalls wird eine Ausnahme/Exception ausgelöst. Diese Flexibilität ermöglicht verschiedene Formen der **Polymorphie**. \n",
+    "Die Summenfunktion `sum` akzeptiert zum Beispiel einen Parameter, von dem angenommen wird, dass er eine Zahlenfolge ist. Sie funktioniert unabhängig davon, ob diese Folge in Form einer Liste, eines Tupels oder einer Menge vorliegt, solange der Parameter iterierbar ist. Eine andere Form des Polymorphismus ist eine Funktion, die sich je nach Parametertyp deutlich unterschiedlich verhält.\n",
+    "\n",
+    "<table>\n",
+    "<tr> <th style=\"width:300px\"> Python </th> <th style=\"width:300px\"> C++ </th> </tr> \n",
+    "<tr> <td>\n",
+    "\n",
+    "```python \n",
+    "def ggt(u, v):\n",
+    "```\n",
+    "</td>\n",
+    "<td>\n",
+    "\n",
+    "```c++\n",
+    "int ggt(int u, int v){}\n",
+    "```\n",
+    "</td></tr> </table>\n",
+    "\n",
+    "\n",
+    "C++ ist eine **statisch typisierte** Sprache. Für jeden Bezeichner ist eine **explizite Typdeklaration** erforderlich, bevor er verwendet werden kann. Das folgende Beispiel zeigt eine Typdeklaration gefolgt von einer Zuweisung, wie sie in in C++ aussehen könnte:\n",
+    "\n",
+    "```{.cpp .numberLines}\n",
+    "    int alter; \n",
+    "    alter = 42; \n",
+    "```\n",
+    "  \n",
+    "Die erste Zeile ist eine Deklaration, die den Bezeichner `alter` als Integer-Wert festlegt.\n",
+    "Typdeklarationen werden in vielen Zusammenhängen verwendet. \n",
+    "Zum Beispiel muss eine **Funktionssignatur** explizite Typ Deklarationen für alle formalen Parameter sowie für den resultierenden Rückgabetyp enthalten. \n",
+    "Alle Datenelemente müssen als Teil einer Klassendefinition explizit typisiert werden. \n",
+    "Der Grund für solche Deklarationen ist, \n",
+    "dass dadurch wesentlich mehr **Arbeit zur Kompilierzeit** und nicht zur Laufzeit erledigt werden kann. \n",
+    "Beispielsweise kann die Korrektheit der Zuweisung `alter = 42` zur Kompilierzeit aufgrund der Kenntnis des Datentyps erfolgen. Ähnlich verhält es sich, wenn ein Programmierer versucht, eine Zeichenkette an eine Funktion zu übergeben, die eine Fließkommazahl erwartet, wie in `sqrt(\"Hallo\")`. Dieser Fehler kann zur Kompilierzeit erkannt werden. In einigen Szenarien, können Typendeklarationen dem System helfen, den Speicher besser zu nutzen. \n",
+    "\n",
+    "Die Entscheidung zwischen dynamisch und statisch typisierten Sprachen ist oft (aber nicht immer) mit der Entscheidung zwischen interpretierten und kompilierten Sprachen gekoppelt. Der **Hauptvorteil der statischen Typisierung ist die frühere Erkennung von Fehlern**, doch ist diese frühzeitige Erkennung bei einer kompilierten Sprache, bei der zwischen Kompilierzeit- und Laufzeitfehlern unterschieden wird, von größerer Bedeutung. Selbst wenn die statische Typisierung in einer rein interpretierten Sprache verwendet wird, werden diese Fehler erst bei der Ausführung des Programms auftreten. Die wichtigsten **Vorteile der dynamischen Typisierung ist der geringere syntaktische Aufwand**, der mit expliziten Deklarationen verbunden ist, sowie die einfachere Unterstützung von Polymorphismus.\n",
+    "\n",
+    "### <font color='blue'>**Warum C++?**</font>\n",
+    "\n",
+    "Im Vergleich zu anderen objektorientierten Sprachen liegt die größte Stärke von C++ in seinem Potenzial zur Erstellung **schneller, ausführbarer Prgramme** und **robuster Bibliotheken**. \n",
+    "Diese Effizienz und Leistungsfähigkeit ist auf eine Reihe von Faktoren zurückzuführen. \n",
+    "C und C++ bieten große Flexibilität bei der **Steuerung vieler der zugrunde liegenden Mechanismen**, \n",
+    "die von einem ausführenden Programm verwendet werden. \n",
+    "Ein Programmierer kann auf **niedriger Ebene** steuern, wie **Daten gespeichert** werden, wie **Informationen weitergegeben** werden und wie der **Speicher verwaltet** wird.\n",
+    "Bei klugem Einsatz kann diese Kontrolle zu einem **schlankeren Ergebnis** führen. \n",
+    "Aufgrund der langen Geschichte von C und C++ und ihrer weiten Verbreitung wurde die **Compilertechnologie zudem stark optimiert**.\n",
+    "\n",
+    "Die größte Schwäche von C++ ist seine **Komplexität**. Ironischerweise geht diese Schwäche Hand in Hand mit genau den Punkten, die wir als Stärken der Sprache beschrieben haben. Als eine Sprache, die seit Jahrzehnten bekannt ist, wurde ihre Entwicklung durch den Wunsch nach **Abwärtskompatibilität** eingeschränkt, \n",
+    "um den großen Bestand an bestehender Software zu unterstützen. \n",
+    "Einige **zusätzliche Funktionen** wurden auf **umständlichere Art und Weise nachgerüstet**, als wenn die Sprache von Grund auf neu entwickelt worden wäre. Dies hat dazu geführt, dass Teile der **Syntax kryptisch** geworden sind. \n",
+    "\n",
+    "Noch wichtiger ist, dass die Flexibilität, die dem Programmierer bei der Steuerung von Low-Level-Aspekten eingeräumt wird, mit **Verantwortung** verbunden ist. \n",
+    "Statt einer Möglichkeit, etwas auszudrücken, kann es fünf **Alternativen** geben. \n",
+    "Ein erfahrener und fachkundiger Entwickler kann diese Flexibilität nutzen, um die **beste Alternative** auszuwählen und das Ergebnis zu optimieren. \n",
+    "Doch sowohl unerfahrene als auch erfahrene Programmierer können leicht die **falsche Alternative** wählen, \n",
+    "was zu weniger effizienter und möglicherweise fehlerhafter Software führt.\n",
+    "\n",
+    "### <font color='blue'>**Ein erster Blick auf C++**</font>\n",
+    "\n",
+    "Wir beginnen mit einer Gegenüberstellung eines Python-Codefragments zur Bestimmung des kleinsten gemeinsamen Teilers zweier Zahlen und des entsprechenden Codes in C++ nach dem Euklidischen Algorithmus.  \n",
+    "Im Detail angesehen, ist die C++-Version etwas **umfangreicher** als der Python Code. \n",
+    "Er sollte hoffentlich lesbar sein, aber es gibt durchaus syntaktische Unterschiede. \n",
+    "Zunächst auf die Verwendung von **Leerzeichen** in Python gegenüber der Verwendung von **Satzzeichen** in C++ zur Abgrenzung der grundlegenden syntaktischen Struktur des Codes hingewiesen. \n",
+    "Auf einen einzelnen Befehl in Python (z. B. `u = v`) folgt ein **Zeilenumbruch**, der offiziell das Ende dieses Befehls bezeichnet. In C++ muss jeder einzelne Befehl **explizit mit einem Semikolon** abgeschlossen werden. \n",
+    "Auch bei der Kennzeichnung eines \"Code-Blocks\" gibt es einen Unterschied. In Python wird jedem Block ein **Doppelpunkt** vorangestellt und der Block wird durch **Einrückung** deutlich gekennzeichnet. \n",
+    "In C++ werden diese Code-Blöcke ausdrücklich in **geschweifte Klammern** { } eingeschlossen. \n",
+    "Diese Schleife ist selbst ist in den Funktionskörper eingebettet, der mit einer linken Klammer beginnt und mit der rechten Klammer endet.\n",
+    "\n",
+    "\n",
+    "<table>\n",
+    "<tr> <th style=\"width:300px\"> Python </th> <th style=\"width:300px\"> C++ </th> </tr> \n",
+    "<tr> <td>\n",
+    "\n",
+    "```python \n",
+    "def ggt(u, v):\n",
+    "    \n",
+    "    while v != 0: \n",
+    "        r = u % v # berechne Rest\n",
+    "        u = v \n",
+    "        v = u \n",
+    "    \n",
+    "    return u\n",
+    "\n",
+    "```\n",
+    "</td>\n",
+    "<td>\n",
+    "\n",
+    "```c++\n",
+    "int ggt(int u, int v){\n",
+    "    int r;\n",
+    "    while (v != 0) {\n",
+    "        r = u % v; // berechne Rest \n",
+    "        u = v;\n",
+    "        v = r;\n",
+    "    }\n",
+    "    return u;\n",
+    "}\n",
+    "```\n",
+    "</td></tr> </table>\n",
+    "\n",
+    "Ein weiterer Unterschied in der Zeichensetzung ergibt sich, da C++ verlangt, dass die **boolesche Bedingung** für die while-Schleife in Klammern ausgedrückt wird. In Python wurde das hier nicht gemacht, obwohl Klammern optional verwendet werden können. \n",
+    "Wir sehen auch einen Unterschied bei der Bereitstellung von Inline-Kommentaren. In Python, wird das Zeichen `#` verwendet. In C++ sind zwei verschiedene Arten von Kommentaren zulässig. \n",
+    "Ein einzeiliger Kommentar wird mit dem Muster `//` gegonnen. \n",
+    "Ein mehrzeiliger Kommentar beginnend mit dem Muster `/*` und endet mit `*/`. \n",
+    "In den meisten Fällen ist die Verwendung von Leerzeichen in C++ irrelevant. \n",
+    "Obwohl unser Beispielcode einen Abstand von einem Befehl pro Zeile und mit Einrückung zur Hervorhebung der Blockstruktur versehen ist, ist dies formal nicht Teil der Sprachsyntax. \n",
+    "Die gleiche Funktion könnte technisch in einer einzigen Zeile wie folgt definiert werden:\n",
+    "\n",
+    "```c++\n",
+    "int ggt(int u,int v){int r;while(v!= 0){r=u%v;u=v;v=r;}return u;}\n",
+    "```\n",
+    "Für den Compiler machte das kein Unterschied. Für den **menschlichen Leser** ist die mehrzeilige Version besser lesbar, so dass man die Nutzung von Leerzeichen, wie bei Python erzwungen, übernehmen sollte. \n",
+    "\n",
+    "Die bedeutenderen Unterschiede zwischen der Python- und der C++-Version unseres Beispiels betreffen den Unterschied zwischen dynamischer und statischer Typisierung. \n",
+    "Selbst in diesem einfachen Beispiel gibt es drei verschiedene Erscheinungsformen der statischen Typisierung. \n",
+    "Die formalen Parameter (d. h. die Bezeichner `u` und `v`) werden in der Python-Signatur ohne explizite Typisierung deklariert. In der entsprechenden Deklaration der Parameter in der C++-Signatur finden wir für jeden Parameter eine explizite Typangabe mit der Syntax `ggt(int u, int v)`. \n",
+    "Diese Information dient dem Compiler zu zwei Zwecken. \n",
+    "**Erstens** ermöglicht sie dem Compiler, die **Rechtmäßigkeit der Verwendung** von `u` und `v` innerhalb des Funktionskörpers zu überprüfen. \n",
+    "Zweitens ermöglicht sie dem Compiler zu **erzwingen**, dass **Ganzzahlen** vom Aufrufer unserer Funktion übergeben werden. \n",
+    "Die zweite Erscheinungsform der statischen Typisierung ist die **explizite Angabe des Rückgabetyps** als Teil einer formalen Signatur in C++. \n",
+    "In der ersten Zeile unseres C++-Beispiels kennzeichnet die Deklaration `int` am Anfang der Zeile diese Funktion als eine Funktion, die eine ganze Zahl zurückgibt. Auch hier verwendet der Compiler diese Kennzeichnung, um die Gültigkeit unseres eigenen Codes zu überprüfen (nämlich dass wir tatsächlich den richtigen Typ von Informationen zurückgeben) und um die Verwendung unseres Rückgabewerts durch den Aufrufer zu überprüfen. \n",
+    "Wenn der Aufrufer die Funktion beispielsweise als Teil einer Zuweisung `g = ggt(54,42)` aufruft, wäre dies legal, wenn die Variable `g` als Ganzzahl deklariert wurde, jedoch illegal, wenn `g` als String deklariert wurde.\n",
+    "\n",
+    "Schließlich sei noch auf die Deklaration der Variablen `r` unseres C++-Codes hingewiesen. \n",
+    "Damit wird `r` als eine **lokale Variable**, die eine ganze Zahl darstellt, deklariert. \n",
+    "Hätten wir die ursprüngliche Deklaration weggelassen, würde der Compiler einen Fehler \"cannot find symbol\" bezüglich der späteren Verwendung von `r` melden (das Analogon zu einem `NameError` in Python). \n",
+    "Formal gesehen hat eine deklarierte Variable einen Geltungsbereich, \n",
+    "der auf dem spezifischsten Satz umschließender Klammern zum Zeitpunkt der Deklaration definiert ist. \n",
+    "In unserem ursprünglichen Beispiel hat die Variable den **Geltungsbereich** als lokale Variable für die Dauer des Funktionskörpers (wie es auch bei unserer Python-Version der Fall ist). \n",
+    "Da diese Variable technisch gesehen nur zum Zweck der vorübergehenden Speicherung während eines einzigen Aufrufs der while-Schleife notwendig ist, hätten wir sie auch innerhalb des **engeren Bereichs** des Schleifenkörpers deklarieren können (**Python** unterstützt diese Form des eingeschränkten Bereichs nicht).\n",
+    "Sie haben vielleicht bemerkt, dass dieses erste Beispiel nicht objektorientiert ist. \n",
+    "Tatsächlich ist das angegebene C++-Codefragment, im Wesentlichen ein C-Codefragment (der einzige Aspekt des Fragments, der nicht mit nicht der C-Sprache entspricht, ist der `//` Stil des Kommentars)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d494b4c2-b5dc-4522-a357-398e3834af86",
+   "metadata": {},
+   "source": [
+    "### <font color='blue'>**C++ Grundlagen**</font>\n",
+    "\n",
+    "#### <font color='blue'>**Datentypen und Operatoren**</font>\n",
+    "\n",
+    "Die folgende Tabelle gibt einen Überblick über die primitiven Datentypen in C++, wobei die Entsprechung zu den Typen in Python zu beachten ist.\n",
+    "\n",
+    "|C++ Typ | Beschreibung      | Literalen  | Python Analogon |\n",
+    "|--------|-------------------|------------|-----------------|\n",
+    "| `bool`   | logischer Wert    | `true` `false`         | `bool` | \n",
+    "| `short`  | Integer (meist 16 bits) | \n",
+    "| `int`    | Integer (meist 32 bits) |  38\n",
+    "| `long`   | Integer (meist 32 oder 64 bits) | 38L  | `int`   | \n",
+    "|          |                   |                    | `long`  |  \n",
+    "| `float`  | Gleitkommazahl (meist 32 bits) | 3.14f |         |\n",
+    "| `double` | Gleitkommazahl (meist 64 bits) | 3.14  | `float` |\n",
+    "| `char`   | Einzel-Character  | 'a' | \n",
+    "| `string` | Character-Sequenz | \"Hello\" | `str` | \n",
+    "\n",
+    "Der Typ `bool` wird von beiden Sprachen unterstützt, obwohl die Literale `true` und `false` in C++ nicht wie in Python **groß geschrieben** werden. \n",
+    "\n",
+    "C++ bietet dem Programmierer eine feinere Kontrolle bei der Festlegung der zugrunde liegenden Genauigkeit von Ganzzahlen und unterstützt drei **verschiedene Ganzzahltypen** mit fester Genauigkeit (`short`, `int` und `long`).\n",
+    "Die Genauigkeit der `int`-Klasse von **Python** entspricht der von `long` in C++. \n",
+    "Der `long`-Typ von Python dient einem völlig anderen Zweck: Er repräsentiert ganze Zahlen mit unbegrenzter Größe. In C++ gibt es keinen solchen Standardtyp (obwohl einige ähnliche Pakete verfügbar sind). \n",
+    "Jeder der Integer-Typen hat eine Variante **ohne Vorzeichen**, die nur nicht-negative Zahlen darstellt. \n",
+    "In der Reihenfolge ihrer Größe sind diese Typen `unsigned char`, `unsigned short`, `unsigned int` und `unsigned long`. Diese Typen sollten in Situationen verwendet werden, in denen Sie wissen, dass der Wert niemals negativ sein wird, z. B. ein Index einer Liste.\n",
+    "\n",
+    "C++ unterstützt zwei verschiedene **Gleitkommatypen** (`float` und `double`) mit einer Auswahl an zugrunde liegenden Genauigkeiten.\n",
+    "Der `double`-Typ in C++ ist der am häufigsten verwendete und entspricht dem `float`-Typ in **Python**.\n",
+    "\n",
+    "C++ unterstützt auch zwei verschiedene Typen für die Darstellung von **Text**. Ein `char`-Typ bietet eine vereinfachte Darstellung eines **einzelnen Zeichens** von Text, während die `string`-Klasse einen ähnlichen Zweck wie die `str`-Klasse von **Python** erfüllt, indem sie eine Folge von Zeichen darstellt.\n",
+    "Um zwischen einem `char` und einer einstelligen Zeichenkette zu unterscheiden, muss ein String-Literal mit **doppelten Anführungszeichen** (wie in \"a\") gekennzeichnet werden. Die Verwendung von **einfachen Anführungszeichen** ist für ein Zeichenliteral (wie in 'a') reserviert. \n",
+    "Ein Versuch, die Syntax mit einfachen Anführungszeichen zu missbrauchen, führt zu einem Kompilierfehler.\n",
+    "Im Gegensatz zu Pythons unveränderlicher `str`-Klasse ist eine C++-Zeichenkette veränderbar. \n",
+    "\n",
+    "Eine Zusammenfassung der am häufigsten verwendeten String-Operationen ist in folgender Tabelle dargestellt. Beachten Sie, dass der Ausdruck `s[index]` sowohl für den Zugriff auf ein bestimmtes Zeichen als auch für die Änderung dieses Zeichens in ein anderes verwendet werden kann, wenn er auf der linken Seite einer Zuweisung steht. Außerdem wird die Syntax `s+t` verwendet, um eine dritte Zeichenkette zu erzeugen, die eine Verkettung der anderen ist, während die Syntax `s.append(t)` die Instanz s verändert.\n",
+    "\n",
+    "\n",
+    "| | nicht-verändernde Methoden |\n",
+    "|--------------|-------------|\n",
+    "| `s.size( )` oder `s.length( )` | Beide Formen geben die Anzahl der Zeichen in der Zeichenkette s zurück.  | \n",
+    "| `s.empty( )`                 | Gibt true zurück, wenn s eine leere Zeichenkette ist, andernfalls false. |\n",
+    "| `s[index]`                   | Gibt das Zeichen der Zeichenkette s am angegebenen Index zurück (unvorhersehbar, wenn index außerhalb des Bereichs liegt).| \n",
+    "| `s.at(index)`                | Gibt das Zeichen der Zeichenkette s am angegebenen Index wieder (wirft eine Ausnahme, wenn index außerhalb des Bereichs liegt). |\n",
+    "| `s == t`                     | Gibt true zurück, wenn die Zeichenketten s und t den gleichen Inhalt haben, false sonst. |\n",
+    "| `s < t`                      | Gibt true zurück, wenn s lexikografisch kleiner als t ist, false andernfalls. |\n",
+    "| `s.compare(t)`               | Gibt einen negativen Wert zurück, wenn die Zeichenkette s lexikografisch kleiner ist als Zeichenkette t ist, null, wenn sie gleich ist, und einen positiven Wert, wenn s größer als t ist. |\n",
+    "| `s.find(pattern, start)`     | Gibt den kleinsten Index, größer oder gleich start, an dem Muster beginnt; gibt string::npos zurück, wenn nicht gefunden. |\n",
+    "| `s.rfind(muster, start)`     | Gibt den größten Index, kleiner oder gleich dem angegebenen Start, an dem das Muster beginnt; gibt string::npos zurück, wenn nicht gefunden. |\n",
+    "| `s.find_first_of(charset, start)` | Gibt den kleinsten Index, größer oder gleich dem angegebenen start, bei dem ein Zeichen des angegebenen Zeichensatzes gefunden wird gefunden wird; gibt string::npos zurück, wenn nicht gefunden. |\n",
+    "| `s.find_last_of(Zeichensatz, start)` | Gibt den größten Index, kleiner oder gleich dem angegebenen start, bei dem ein Zeichen des angegebenen Zeichensatzes gefunden wird gefunden wird; gibt string::npos zurück, wenn es nicht gefunden wird.|\n",
+    "| `s + t` | Gibt eine Verkettung der Zeichenketten s und t zurück.|\n",
+    "| `s.substr(start)` | Gibt die Teilzeichenkette vom Index start bis zum Ende wieder.|\n",
+    "| `s.substr(start, num)` | Gibt die Teilzeichenkette vom Index start bis zum Ende wieder, wobei num Zeichen.|\n",
+    "\n",
+    "\n",
+    "|              | verändernde Methoden |\n",
+    "|--------------|----------------------|\n",
+    "|`s[index] = newChar` | Ändert die Zeichenkette s, indem das Zeichen am angegebenen Index in das neue Zeichen (unvorhersehbar, wenn der Index außerhalb des Bereichs).|\n",
+    "|`s.append(t)` | Ändert die Zeichenkette s durch Anhängen der Zeichen der Zeichenkette t.|\n",
+    "|`s.insert(index, t)` | Fügt eine Kopie der Zeichenkette t am angegebenen Index in die Zeichenkette s ein.|\n",
+    "|`s.insert(index, t, num)` | Fügt num Kopien von t in string am angegebenen Index ein.|\n",
+    "|`s.erase(start)` | Entfernt alle Zeichen vom Startindex bis zum Ende.|\n",
+    "|`s.erase(start, num)` | Entfernt num Zeichen, beginnend beim angegebenen Index.|\n",
+    "|`s.replace(index, num, t)` | Ersetzt num Zeichen der aktuellen Zeichenkette, beginnend beim angegebenen Index, durch die ersten num Zeichen von t. |\n",
+    "\n",
+    "#### <font color='blue'>**Typ-Deklarationen**</font>\n",
+    "\n",
+    "Die Grundform einer Typendeklaration kennen wir von oben:\n",
+    "\n",
+    "```c++\n",
+    "    int r;\n",
+    "```\n",
+    "\n",
+    "Es ist auch möglich, eine Variablendeklaration mit einer Initialisierungsanweisung zu kombinieren, \n",
+    "wie in\n",
+    "\n",
+    "```c++\n",
+    "    int alter = 42;\n",
+    "```\n",
+    "\n",
+    "Die bevorzugte Syntax für die Initialisierung in C++ ist jedoch die folgende:\n",
+    "\n",
+    "```c++\n",
+    "    int alter(42);\n",
+    "```\n",
+    "\n",
+    "Darüber hinaus können wir mehrere Variablen desselben Typs in einer einzigen Anweisung deklarieren \n",
+    "(mit oder ohne initiale Werten), wie in\n",
+    "\n",
+    "```c++\n",
+    "    int alter(42), zipcode(63103); // zwei neue Variablen\n",
+    "```\n",
+    "\n",
+    "#### <font color='blue'>**Konstante Typen**</font>\n",
+    "\n",
+    "In Python wird häufig zwischen veränderlichen und unveränderlichen Typen unterschieden (z. B. Liste vs. Tupel). \n",
+    "C++ verfolgt einen anderen Ansatz. Typen sind in der Regel veränderlich, doch kann man eine einzelne Instanz als unveränderlich kennzeichnen. \n",
+    "Dies geschieht durch die Verwendung des Schlüsselworts `const` als Teil der Deklaration, wie in \n",
+    "\n",
+    "```c++\n",
+    "    const int alter(42); // Unsterblichkeit\n",
+    "```\n",
+    "\n",
+    "Diese Unveränderlichkeit wird vom Compiler streng erzwungen, so dass jeder nachfolgende Versuch, diesen Wert zu ändern, z.B. mit `alter++`, zu einem Kompilierfehler führt.\n",
+    "\n",
+    "#### <font color='blue'>**Operatoren**</font>\n",
+    "\n",
+    "Abgesehen von einigen bemerkenswerten Unterschieden unterstützen die beiden Sprachen einen sehr ähnlichen Satz von Operatoren für die primitiven Typen. Es werden dieselben grundlegenden **logischen Operatoren** unterstützt, aber C++ verwendet die folgenden Symbole (die aus der Syntax von C):\n",
+    "\n",
+    "| C++ | Bedeutung | Python | \n",
+    "|-----|-----------|--------|\n",
+    "| `&&`   | für logisch und   | `and` |\n",
+    "| `\\|\\|` | für logisch oder  | `or` |\n",
+    "| `!`    | für logisch nicht | `not` | \n",
+    "\n",
+    "Bei numerischen Werten unterscheidet Python zwischen echter **Division** (d.h. `/`), ganzzahliger Division (d.h. `//`) und modulare Arithmetik (z. B. `%`). C++ unterstützt die Operatoren `/` und `%`, aber nicht `//` (dieses Muster dient bereits zur Kennzeichnung von Inline-Kommentaren in C++). \n",
+    "Die Semantik des Operators `/` hängt vom Typ der Operanden ab. \n",
+    "Wenn beide Operanden ganzzahlige Typen sind, ist das Ergebnis der ganzzahlige Quotient. \n",
+    "Sind einer oder beide Operanden Fließkomma-Typen, wird eine echte Division durchgeführt. \n",
+    "Um eine echte Division mit ganzzahligen Typen zu erhalten, \n",
+    "muss einer der Operanden explizit in eine Fließkommazahl umgewandelt werden.\n",
+    "\n",
+    "Wie Python unterstützt auch C++ eine **Operator-mit-Zuweisung** für die meisten binären Operatoren, wie z. B. x += 5 als Abkürzung für x = x + 5. Darüber hinaus unterstützt C++ einen **++-Operator** für die übliche Aufgabe, eine Zahl um eins zu inkrementieren. In der Tat gibt es zwei verschiedene Verwendungen, die als **Prä-Inkrement** (z. B. `++x`) und **Post-Inkrement** (z. B. `x++`). In beiden Fällen wird der Wert von `x` um eins erhöht, aber sie können im Kontext eines größeren Ausdrucks unterschiedlich verwendet werden. \n",
+    "Wenn Sie beispielsweise eine Sequenz indizieren, greift der Ausdruck `groceries[i++]` auf den Wert mit dem ursprünglichen Index `i` zu und erhöht anschließend diesen Index. Im Gegensatz dazu bewirkt die Syntax `groceries[++i]`, dass der Wert des Index inkrementiert wird, bevor auf den zugehörigen Eintrag der Sequenz zugegriffen wird. \n",
+    "Der **Operator** `--` wird in ähnlicher Weise in Form von Prä-Dekrementen und Post-Dekrementen unterstützt. \n",
+    "Diese Kombination von Operatoren kann für einen Programmierer wertvoll sein, aber ihre Verwendung führt aber auch zu **sehr subtilem Code** und manchmal zu **Fehlern**. Wir empfehlen, dass sie sparsam verwendet werden bis sie richtig beherrscht werden.\n",
+    "\n",
+    "#### <font color='blue'>**Konvertierung zwischen Typen**</font>\n",
+    "\n",
+    "In Python werden Typumwandlung oft **implizit** durchgeführt wird. \n",
+    "Zum Beispiel, wenn der Addition `1.5 + 8` wird der zweite Operand in eine Fließkommadarstellung umgewandelt, bevor die Addition durchgeführt wird.\n",
+    "\n",
+    "Es gibt ähnliche Situationen, in denen C++ einen Wert implizit in einen anderen Typ umwandelt. \n",
+    "Aufgrund der statischen Typisierung kann zusätzliches implizites **Casting** stattfinden, \n",
+    "wenn ein Wert eines Typs einer Variablen eines anderen Typs zugewiesen wird.\n",
+    "Betrachten Sie das folgende Beispiel:\n",
+    "\n",
+    "```c++\n",
+    "    int a(5);\n",
+    "    double b;\n",
+    "    b = a; // setzt b auf 5.0\n",
+    "```\n",
+    "\n",
+    "Der letzte Befehl bewirkt, dass `b` eine **interne Fließkommadarstellung** des Wertes `5.0` erhält und nicht die Ganzzahldarstellung. Dies liegt daran, dass die Variable `b` ausdrücklich als vom Typ `double` bezeichnet wurde. Wir können auch einer `int`-Variablen einen `double`-Wert zuweisen, aber bei einem solchen **impliziten Cast** gehen möglicherweise Informationen verloren. \n",
+    "Für Beispiel: Das Speichern eines Fließkommawertes in einer Integer-Variablen führt dazu, dass alle Nachkommastellen abgeschnitten werden.\n",
+    "\n",
+    "```c++\n",
+    "    int a;\n",
+    "    double b(2.67);\n",
+    "    a = b; // setzt a auf 2\n",
+    "```\n",
+    "\n",
+    "Es gibt viele Szenarien, in denen C++ implizit zwischen Typen konvertiert, die normalerweise nicht als als kompatibel gelten. Einige Compiler geben eine Warnung aus, um auf solche Fälle aufmerksam zu machen, aber es gibt keine Garantie.\n",
+    "\n",
+    "Manchmal ist es erfoderlich eine Typumwandlung mit einem **expliziten Cast** zu erzwingen, die sonst nicht durchgeführt werden würde. Dies geschieht mit einer Syntax ähnlich wie in Python, wo der Name des Zieltyps wie eine Funktion verwendet wird.\n",
+    "\n",
+    "```c++\n",
+    "    int a(4), b(3);\n",
+    "    double c;\n",
+    "    c = a / b;          // setzt c auf 1.0\n",
+    "    c = double(a) / b;  // setzt c auf 1.33\n",
+    "```\n",
+    "\n",
+    "Die erste Zuweisung an `b` ergibt `1.0`, da die Umwandlung in einen `double` erst nach der Ganzzahldivision `a/b` durchgeführt wird. Im zweiten Beispiel führt die **explizite Umwandlung** des Werts von `a` in einen `double` wird eine echte Division durchgeführt (wobei `b` implizit erzwungen wird). \n",
+    "Es lassen sich jedoch nicht alle derartigen Umwandlungen durch Casting durchführen. \n",
+    "Beispielsweise gibt es standarmäßig nicht die in **Python** vorhandene Möglichkeit für die Umwandlung einer Zahl in eine Zeichenkette wie bei `str(17)` oder die Konvertierung einer Zeichenkette in die entsprechende Zahl wie bei `int('17')`. \n",
+    "Leider erfordern Konvertierungen zwischen Zeichenketten weitergehende Techniken wie die Handhabung von Ein- und Ausgaben. \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c699ed6f-8fa5-4267-80e4-ebe6df2fc012",
+   "metadata": {},
+   "source": [
+    "#### <font color='blue'>**Kontrollstrukturen**</font>\n",
+    "\n",
+    "##### <font color='blue'>**while-Schleifen**</font>\n",
+    "\n",
+    "Die `while`-Schleife ist bereits vorgestellt worden. Die Grundstruktur ist ähnlich, mit nur leichten Unterschieden in der Syntax. Die Klammern um die boolesche Bedingung sind in C++ erforderlich. \n",
+    "Geschweifte Klammern wurden verwendet, um den Befehlsblock abzugrenzen, die den Hauptteil der Schleife ausmachen. \n",
+    "Praktisch gesehen sind diese geschweiften Klammern nur dann erforderlich, wenn der Schleifenkörper aus zwei oder mehr  Anweisungen besteht. Ohne geschweifte Klammern wird angenommen, dass der nächste einzelne Befehl den Hauptteil bildet.\n",
+    "\n",
+    "C++ unterstützt auch eine `do-while`-Syntax. Hier C++-Codefragment für die Abfrage einer Zahl zwischen 1 und 10 bis zum Erhalt einer solchen Zahl:\n",
+    "\n",
+    "```c++\n",
+    "    int i = 2;\n",
+    "    do { // Schleifenblock \n",
+    "        cout << \"Hello World\\n\";\n",
+    "        i++;\n",
+    "    }\n",
+    "    while (i < 1); // Test-Bedingung\n",
+    "```\n",
+    "\n",
+    "##### <font color='blue'>**for-Schleifen**</font>\n",
+    "\n",
+    "C++ unterstützt `for`-Schleifen allerdings mit einer ganz anderen Semantik als Python. \n",
+    "Der Stil geht auf C zurück und eine lesbarere Form des typischen indexbasierten Schleifenmuster. \n",
+    "Ein Beispiel für eine Schleife, die zum Abwärtszählen von 10 bis 1 verwendet wird, lautet wie folgt:\n",
+    "\n",
+    "```c++\n",
+    "    for (int count = 10; count > 0; count−−)\n",
+    "        cout << count << endl;\n",
+    "    cout << \"Ende!\";\n",
+    "```\n",
+    "\n",
+    "Innerhalb der Klammern der `for`-Schleife befinden sich drei verschiedene Komponenten, die jeweils durch ein Semikolon getrennt sind. \n",
+    "Der erste Teil ist ein Initialisierungsschritt, der einmalig vor Beginn der Schleife ausgeführt wird. \n",
+    "Der zweite Teil ist eine Schleifenbedingung, die genau wie eine Schleifenbedingung einer while-Schleife behandelt wird; \n",
+    "die Bedingung wird vor jeder Iteration getestet und die Schleife wird fortgesetzt, wenn sie wahr ist. \n",
+    "Abschließend steht die Aktualisierungsanweisung, die automatisch am Ende jeder abgeschlossenen Iteration ausgeführt wird. \n",
+    "Die `for`-Schleifensyntax ist eigentlich nur eine bequeme Alternative zu einer `while`-Schleife, die in einigen Fällen die Logik besser verdeutlicht. Das vorige Beispiel verhält sich im Wesentlichen identisch mit der folgenden Version:\n",
+    "\n",
+    "```c++\n",
+    "    int count = 10;     // Initialisierungsschritt \n",
+    "    while (count > 0) { // Schleifenbedingung \n",
+    "        cout << count << endl;\n",
+    "        count−−;        // Dekrementierung\n",
+    "    }\n",
+    "    cout << \"Ende!\";\n",
+    "```\n",
+    "\n",
+    "Die `for`-Schleife ist allgemeiner. Es ist zum Beispiel möglich, mehrere Initialisierungs- oder Aktualisierungsschritte Schritte in einer `for`-Schleife auszudrücken. Dies geschieht durch die Verwendung von Kommas zur Trennung der einzelnen Anweisungen (im Gegensatz zu dem Semikolon, das die drei verschiedenen Komponenten der Syntax voneinander abgrenzt). \n",
+    "Zum Beispiel könnte die Summe der Werte von 1 bis 10 berechnet werden, indem zwei verschiedene Variablen wie folgt gepflegt werden:\n",
+    "\n",
+    "```c++\n",
+    "    int count, total;\n",
+    "    for (count = 1, total = 0; count <= 10; count++)\n",
+    "        total += count;\n",
+    "```\n",
+    "\n",
+    "\n",
+    "##### <font color='blue'>**Konditionale**</font>\n",
+    "\n",
+    "Eine einfache `if`-Anweisung ist analog aufgebaut und erfordert Klammern um die boolesche Bedingung und geschweifte Klammern um einen zusammengesetzten Körper. \n",
+    "Ein einfaches Beispiel ist eine Konstruktion, die eine negative Zahl in ihren absoluten Wert.\n",
+    "\n",
+    "```c++\n",
+    "    if (x < 0)\n",
+    "        x = -x;\n",
+    "```\n",
+    "\n",
+    "Für den Block mit einem einzelnen Befehl werden keine geschweiften Klammern benötigt. \n",
+    "C++ verwendet nicht das Schlüsselwort `elif` für die Verschachtelung von Konditionalen, \n",
+    "aber es ist möglich, eine neue `if`-Anweisung innerhalb des Körpers einer `else`-Klausel zu verschachteln.\n",
+    "Außerdem wird ein bedingtes Konstrukt syntaktisch wie ein einzelner Befehl behandelt, \n",
+    "so dass ein typisches Muster keine übermäßigen geschweiften Klammern erfordert. \n",
+    "Hier ein Beispiel-Code in C++ geschrieben mit den Einrückungen von Python \n",
+    "(unter der Annahme, dass `Lebensmittel` ein geeigneter Container sind):\n",
+    "\n",
+    "```c++\n",
+    "    if ( lebensmittel.length( ) > 15 )\n",
+    "        cout << \"Gehe in den Lebensmittelladen\"; \n",
+    "    else if ( lebensmittel.contains(\"milk\") )\n",
+    "        cout << \"Gehe zum Gemischtwarenladen\";\n",
+    "```\n",
+    "\n",
+    "Hat man viele Fälle zu unterscheiden bietet sich die case-switch-Struktur an: \n",
+    "\n",
+    "```c++\n",
+    "    int jahreszeit = 2;\n",
+    "    switch (jahreszeit) {\n",
+    "      case 1:\n",
+    "        cout << \"Frühling\";\n",
+    "        break;\n",
+    "      case 2:\n",
+    "        cout << \"Sommer\";\n",
+    "        break;\n",
+    "      case 3:\n",
+    "        cout << \"Herbst\";\n",
+    "        break;\n",
+    "      case 4:\n",
+    "        cout << \"Winter\";\n",
+    "        break;\n",
+    "      default:\n",
+    "        cout << \"Fasching\";\n",
+    "    }\n",
+    "```\n",
+    "\n",
+    "Mit dem `break` Schlüsselwort wird aus dem case-switch-Block ausgebrochen. \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3d58f882-d9c9-45da-99d5-a2f0a2a9e409",
+   "metadata": {},
+   "source": [
+    "#### <font color='blue'>**Funktionen**</font>\n",
+    "\n",
+    "Wir haben bereits oben ein Beispiel für eine C++-Funktion gegeben. \n",
+    "In diesem Abschnitt folgen zwei Beispiele.\n",
+    "In diesem ersten Beispiel haben wir die Notwendigkeit betont, \n",
+    "den Typ jedes einzelnen Parameters sowie den zurückgegebenen Typ explizit anzugeben. \n",
+    "Wenn die Funktion **keinen Rückgabewert** liefert, gibt es ein spezielles **Schlüsselwort** `void`, \n",
+    "das das Fehlen eines Typs angibt. Hier ist eine solche Funktion, die einen Countdown von 10 bis 1 ausgibt: \n",
+    "\n",
+    "\n",
+    "```c++\n",
+    "    void countdown( ) {\n",
+    "        for (int count = 10; count > 0; count−−)\n",
+    "        cout << count;\n",
+    "    }\n",
+    "```\n",
+    "\n",
+    "Ähnlich wie in Python gibt es auch die Möglichkeit, eine alternative Version dieser Funktion mit einer anderen Signatur zu verwenden:  \n",
+    "\n",
+    "```c++\n",
+    "    void countdown(int start=10, int end=1) {\n",
+    "        for (int count = start; count >= end; count−−)\n",
+    "            cout << count;\n",
+    "    }\n",
+    "```\n",
+    "\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "@deathbeds/ipydrawio": {
+   "xml": ""
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/Semester_2/Einheit_10/Pics/Compiler.png b/Semester_2/Einheit_10/Pics/Compiler.png
new file mode 100644
index 0000000000000000000000000000000000000000..e280582cec506b6df0342d9bfab91b28254c4df9
Binary files /dev/null and b/Semester_2/Einheit_10/Pics/Compiler.png differ
diff --git a/Semester_2/Einheit_10/Pics/Interpreter.png b/Semester_2/Einheit_10/Pics/Interpreter.png
new file mode 100644
index 0000000000000000000000000000000000000000..1c4172e89ed1e95067fcf04d22bed114c9f95166
Binary files /dev/null and b/Semester_2/Einheit_10/Pics/Interpreter.png differ
diff --git a/Semester_2/Einheit_10/Pics/Sprachen.png b/Semester_2/Einheit_10/Pics/Sprachen.png
new file mode 100644
index 0000000000000000000000000000000000000000..f37d7c3fc0184d39a088450ef3d7ec086d39ff71
Binary files /dev/null and b/Semester_2/Einheit_10/Pics/Sprachen.png differ