diff --git a/Semester_2/Einheit_11/Grundlagen-Python-to-C++.ipynb b/Semester_2/Einheit_11/Grundlagen-Python-to-C++.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..966d5d01aa5c82e59a44756a21217fd6cb066050
--- /dev/null
+++ b/Semester_2/Einheit_11/Grundlagen-Python-to-C++.ipynb
@@ -0,0 +1,1305 @@
+{
+ "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 erforderlich 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",
+ "\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",
+ "#### <font color='blue'>**Vollständige Programme**</font>\n",
+ "\n",
+ "Um ein vollständiges C++-Programm zu entwickeln, müssen einige Fragen beantwortet werden. Was soll geschehen, wenn das Programm ausgeführt wird? Wo beginnt der Kontrollfluss? Bei Python beginnt der Kontrollfluss am dem Anfang des Quellcodes. Die Befehle werden nacheinander interpretiert, und so kann ein triviales Python Programm könnte also einfach wie folgt aussehen\n",
+ "\n",
+ "```python \n",
+ "print( 'Hallo Welt' )\n",
+ "```\n",
+ "In C++ können Anweisungen im Allgemeinen nicht ohne Kontext ausgeführt werden. Wenn eine ausführbare Datei durch das Betriebssystem gestartet wird, beginnt der Kontrollfluss mit einem Aufruf einer speziellen Funktion namens `main`. \n",
+ "Der obige Python-Code lässt sich am direktesten als das folgende Programm in C++ übersetzen:\n",
+ "\n",
+ "```c++\n",
+ "1 #include <iostream>\n",
+ "2 using namespace std;\n",
+ "3 int main( ) {\n",
+ "4 cout << \"Hello World.\" << endl;\n",
+ "5 return 0;\n",
+ "6 }\n",
+ "```\n",
+ "\n",
+ "Der Rückgabewert für `main` ist eine kleine Formsache. \n",
+ "Die Signatur muss einen `int`-Rückgabetyp vorsehen. \n",
+ "Der tatsächlich zurückgegebene Wert wird am Ende des Programms an das Betriebssystem zurückgemeldet. \n",
+ "Es ist dem Betriebssystem überlassen, wie es diesen Wert interpretiert, obwohl Null historisch gesehen eine erfolgreiche Ausführung anzeigt, während andere Werte als Fehlercodes verwendet werden.\n",
+ "\n",
+ "Um zu demonstrieren, wie man ein C++-Programm kompiliert und ausführt, stellen ein zweites Beispiel vor.\n",
+ "Es handelt sich um ein recht einfaches Programm, das auf die Funktion zur Bestimmung des größten gemeinsamen Nenner zurückgreift \n",
+ "und dafür vom Benutzer eingegebenen Zahlen nutzt. \n",
+ "\n",
+ "```c++\n",
+ " 1 #include <iostream>\n",
+ " 2 using namespace std;\n",
+ " 3\n",
+ " 4 int ggt(int u, int v) {\n",
+ " 5 int r;\n",
+ " 6 while (v != 0) {\n",
+ " 7 r = u % v;\n",
+ " 8 u = v;\n",
+ " 9 v = r;\n",
+ "10 }\n",
+ "11 return u;\n",
+ "12 }\n",
+ "13\n",
+ "14 int main( ) {\n",
+ "15 int a, b;\n",
+ "16 cout << \"Eingabe der ersten Zahl: \";\n",
+ "17 cin >> a;\n",
+ "18 cout << \"Eingabe der zweiten Zahl: \";\n",
+ "19 cin >> b;\n",
+ "20 cout << \"Größter gemeinsamer Teiler ist:\" << ggt(a,b) << endl;\n",
+ "21 return 0;\n",
+ "22 }\n",
+ "```\n",
+ "\n",
+ "Nehmen wir an, dass der Quellcode gespeichert ist in einer Datei `ggt.cpp` gespeichert ist. \n",
+ "Der am weitesten verbreitete Compiler ist von einer Organisation namens GNU, und der Compiler wird in der Regel als ein Programm namens g++ auf einem System installiert. Der Compiler kann direkt von der der Befehlszeile des Betriebssystems mit folgender Syntax aufgerufen werden,\n",
+ "```c++\n",
+ "g++ -o gcd gcd.cpp\n",
+ "```\n",
+ "Der Compiler meldet alle Syntaxfehler, die er findet, aber wenn alles gut geht, erzeugt er eine neue Datei namens `gcd`, die eine ausführbare Datei ist. Sie kann auf dem Computer genauso gestartet werden. Beim Windows-Betriebssystem muss diese ausführbare Datei möglicherweise gcd.exe heißen. Es gibt auch integrierte Entwicklungsumgebungen für C++ (wie z. B. Python's IDLE). Diese stützen sich in der Regel auf denselben zugrundeliegenden Compiler.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "445f5aa8-200f-41dc-9839-6602bc499de0",
+ "metadata": {},
+ "source": [
+ "### <font color='blue'>**Eingabe und Ausgabe**</font>\n",
+ "\n",
+ "Eingaben und Ausgaben können mit einer Vielzahl von Quellen in einem Computerprogramms verbunden sein: Eingaben über die Tastatur, Ausgabe auf dem Bildschirm, Lesen oder Schreiben aus bzw. in eine Datei, Übertragung über ein Netzwerk.\n",
+ "\n",
+ "Zur Vereinheitlichung von Eingabe und Ausgabe stützt sich C++ auf ein Bibliothek von Klassen zur Unterstützung einer Abstraktion, die als **\"Stream\"** (Strom) bezeichnet wird. \n",
+ "So können Daten in einen Stream eingefügt werden, um sie an eine andere Stelle zu senden oder Daten aus einem bestehenden Stream extrahieren. \n",
+ "Ein Eingabe-Stream wird durch die Klasse **istream** dargestellt und ein Ausgabe-Stream durch die Klasse **ostream**. \n",
+ "Einige Streams (**iostream**) können sowohl als Eingabe als auch als Ausgabe dienen. \n",
+ "Dann gibt es noch spezifischere Klassen, z.B. zur Handhabung von eine Datei die Klasse fstream.\n",
+ "\n",
+ "#### <font color='blue'>**Bibliotheken**</font>\n",
+ "\n",
+ "Die hierfür benötigten Funktionalitäten sind nicht automatisch in C++ verfügbar. \n",
+ "Die meisten sind in einer Standardbibliothek namens `iostream` (kurz für \"input/output streams\") definiert. Eine **C++-Bibliothek** erfüllt einen ähnlichen Zweck wie ein Python-Modul. \n",
+ "Wir müssen die Definitionen aus der Bibliothek formell einbinden, bevor wir sie verwenden.\n",
+ "\n",
+ "```c++\n",
+ " #include <iostream>\n",
+ " using namespace std;\n",
+ "```\n",
+ "\n",
+ "\n",
+ "Die erste Anweisungen importiert die Bibliothek, während die zweite diese Definitionen in unseren Standard-Namespace bringt. \n",
+ "Zusätzlich zu den grundlegenden Klassendefinitionen definiert diese Bibliothek zwei spezielle Instanzen für die Verarbeitung von Eingaben in und von der Standardkonsole. \n",
+ "\n",
+ "* `cout` (kurz für \"console output\") ist ein Objekt, das verwendet wird, um Nachrichten an den Benutzer zu drucken, und \n",
+ "* `cin` (kurz für \"console input\") wird verwendet, um vom Benutzer getippte Eingaben zu erhalten.\n",
+ "\n",
+ "#### <font color='blue'>**Console Output**</font>\n",
+ "\n",
+ "In C++ werden Konsolenausgaben über den `cout`-Stream aus der iostream-Bibliothek erzeugt. \n",
+ "Streams unterstützen den **Operator** `<<`, um Daten in den Stream einzufügen, wie in `cout << \"Hallo\"`. Das Symbol `<<` wurde gewählt, um unterschwellig den Datenfluss zu suggerieren, wenn die Zeichen von \"Hallo\" in den Stream geschickt werden. \n",
+ "Wie beim `print` in Python, versucht C++, eine Textdarstellung für alle Daten, die keine Zeichenketten sind, zu erzeugen, die in den Ausgabestrom gelangen. \n",
+ "Mehrere Elemente können mit einem einzigen Befehl in den Stream eingefügt werden, indem der Operators in den Stream eingefügt werden, wie in `cout << \"Hello\"<< \" und \"<< \"Goodbye\"`. \n",
+ "Im Gegensatz zum Python `print`-Befehl müssen explizit Leerzeichen eingefügt werden, wenn sie gewünscht sind. Gleiches gilt auch für Zeilenumbrüche: man kann das Escape-Zeichen, `\\n`, direkt in eine Zeichenkette einbetten, aber C++ bietet die portablere Definition eines speziellen Objekts `endl`, das ein Zeilenvorschubzeichen darstellt.\n",
+ "\n",
+ "Im folgenden Beispiel sind die Variablen `first` und `last` zuvor als Strings definiert und `count` als ganze Zahl.\n",
+ "\n",
+ "<table>\n",
+ "<tr> <th style=\"width:400px\"> Python </th> <th style=\"width:400px\"> C++ </th> </tr> \n",
+ "<tr> <td>\n",
+ "\n",
+ "```python \n",
+ "1 print \"Hallo\"\n",
+ "2 print\n",
+ "3 print \"Hallo,\", first\n",
+ "4 print first, last # automatische Leerzeichen\n",
+ "5 print count\n",
+ "6 print str(count) + \".\" # keine Leerzeichen\n",
+ "7 print \"Warte...\", # Leezeichen ohne neue Zeile\n",
+ "8 print \"Fertig\"\n",
+ "```\n",
+ "</td>\n",
+ "<td>\n",
+ "\n",
+ "```c++\n",
+ "1 cout << \"Hallo\" << endl;\n",
+ "2 cout << endl;\n",
+ "3 cout << \"Hallo, \" << first << endl;\n",
+ "4 cout << first << \" \" << last << endl;\n",
+ "5 cout << count << endl;\n",
+ "6 cout << count << \".\" << endl;\n",
+ "7 cout << \"Warte... \"; // no newline\n",
+ "8 cout << \"Fertig\" << endl;\n",
+ "```\n",
+ "</td></tr> </table>\n",
+ "\n",
+ "#### <font color='blue'>**Formatierter Output**</font>\n",
+ "\n",
+ "In Python kann beispielsweise die Formatierung innerhalb Zeichenketten mit den Formatbescheibern \n",
+ "`%[flags][width][.precision]type` erfolgen, die dem `printf` von C nachempfunden ist: \n",
+ "\n",
+ "```python\n",
+ "print '%s: Rang %d von %d Teams' % (team, rank, total)\n",
+ "```\n",
+ "In C++ als ein direkter Abkömmling von C ist diese Funktion über eine Bibliothek verfügbar, ist aber normalerweise nicht der empfohlene Weg. \n",
+ "Stattdessen wird die formatierte Ausgabe direkt über den Ausgabestrom Stream erzeugt. \n",
+ "Da Datentypen automatisch in Strings konvertiert werden, kann das obige Beispiel in C++ als\n",
+ "\n",
+ "```c++\n",
+ "cout << team << \": Rang \" << rang << \" von \" << total << \" Teams\" << endl;\n",
+ "```\n",
+ "Dieser Ansatz ist nicht ganz so ansprechend wie der vorherige, aber in diesem Fall erfüllt er seine Aufgabe. Mehr Aufwand ist nötig, um andere Aspekte der Formatierung zu steuern, wie z.B. die Genauigkeit von Fließkommawerten. \n",
+ "In Python kann der Ausdruck \"pi ist %.3f'% 3.14159265\" das Ergebnis \"pi ist 3.142\". \n",
+ "In C++ bietet die iomanip-Bibliothek zusätzliche Mechanismen für die Formatierung der Ausgabe zur Verfügung. \n",
+ "Diese Manipulatoren werden an den Ausgabestrom gesendet auf die gleiche Weise wie `endl` verwendet. Zu den üblichen Manipulatoren gehören das Setzen der Breite des nächsten Feldes mit `setw(width)` oder die Genauigkeit der Ausgabe. Zum Beispiel,\n",
+ "\n",
+ "```c++\n",
+ "cout << setw(10) << 123 << endl;\n",
+ "```\n",
+ "\n",
+ "würde die Zahl `123` rechtsbündig mit 7 Leerzeichen anzeigen. \n",
+ "Diese Formatierung hat keine Auswirkung auf weiter folgende Ausgaben.\n",
+ "Für Fließkommazahlen kann die Anzeige entweder auf feste Genauigkeit oder wissenschaftliche Notation eingestellt werden. Um alle Fließkommazahlen mit fester Genauigkeit und 2 Nachkommastellen anzuzeigen, wären die Formtierungen:\n",
+ "\n",
+ "```c++\n",
+ "cout << fixed << setprecision(2);\n",
+ "```\n",
+ "\n",
+ "Um die wissenschaftliche Notation zu verwenden, bitte `cout << scientific;` verwenden. \n",
+ "Diese Formatierungseinstellungen bleiben so lange wirksam, bis sie geändert werden. \n",
+ "Andere Manipulatoren erlauben es Ihnen, die Ausrichtung zu ändern, das Füllzeichen zu setzen, die Basis der Zahlen zu ändern oder die Darstellung von boolschen Werten zu steuern.\n",
+ "\n",
+ "\n",
+ "#### <font color='blue'>**Console Input**</font>\n",
+ "\n",
+ "So wie `cout` ein Ausgabestrom für die Konsole ist, ist `cin` ein Eingabestrom, der zum Lesen von der Konsole verwendet wird. Hier ist ein einfaches Beispiel für seine Verwendung.\n",
+ "\n",
+ "```c++\n",
+ "int Zahl;\n",
+ "cout << \"Geben Sie eine Zahl von 1 bis 10 ein: \"; // Eingabeaufforderung ohne Zeilenumbruch\n",
+ "cin >> Zahl;\n",
+ "```\n",
+ "\n",
+ "Der Operator `>>` extrahiert Daten aus dem Stream und speichert sie in der angegebenen Variablen. \n",
+ "Die statische Typisierung von C++ hilft uns hier im Vergleich zu Python tatsächlich weiter. \n",
+ "Da `number` bereits eindeutig als Ganzzahl bezeichnet wurde, wandelt C++ die Eingabe automatisch in eine Zahl um. \n",
+ "In Python würde der rohe Eingabe-String geholt und anschließend müsste er explizit umgewandelt werden: \n",
+ "\n",
+ "```python\n",
+ "Zahl = int( raw_input( 'Geben Sie eine Zahl zwischen 1 bis 10 ein: ') ) \n",
+ "```\n",
+ "\n",
+ "Es gibt noch weitere Unterschiede bei der Behandlung von Eingaben. \n",
+ "In Python liest der Befehl `raw_input` eine Zeile auf einmal. \n",
+ "In C++ werden beim Extrahieren von Daten aus einem Stream nur so viele Zeichen verwendet, wie nötig sind. Hier ein Codefragment, dass den Benutzer auffordert, zwei Zahlen in dieselbe Zeile einzugeben, um deren Summe zu berechnen.\n",
+ "\n",
+ "```c++\n",
+ "int a, b;\n",
+ "cout << \"Geben Sie zwei ganze Zahlen ein: \";\n",
+ "cin >> a >> b;\n",
+ "cout << \"Ihre Summe ist \" << a+b << \".\" << endl;\n",
+ "```\n",
+ "\n",
+ "Wenn eine Zeichenkette angefordert wird, springt der Stream zum ersten Nonwhitespace-Zeichen und geht von dort bis zum nächsten Whitespace-Zeichen. Das ist anders als bei Python. \n",
+ "Nehmen wir an, wir führen `name = raw_input('Wie ist Ihr Name?)` aus, und der Benutzer antwortet wie folgt: \n",
+ "\n",
+ "```python \n",
+ "Wie lautet Ihr Name? Max Mustermann \n",
+ "```\n",
+ "\n",
+ "In Python würde die gesamte Zeile als Zeichenkette `Max Mustermann` gespeichert werden. \n",
+ "Bei analoger Benutzerinteraktion mit dem folgenden C++-Code,\n",
+ "\n",
+ "```c++\n",
+ "string name;\n",
+ "cout << \"Wie lautet Ihr Name? \";\n",
+ "cin >> name;\n",
+ "```\n",
+ "\n",
+ "wäre das Ergebnis, dass Name `Max` zugewiesen wird. Die anderen Zeichen verbleiben im Stream bis zu einer späteren Extraktion. \n",
+ "\n",
+ "Wenn wir in C++ eine ganze Zeile auf einmal lesen wollen, können wir dies mit der Syntax `getline(cin, name)` erledigen.\n",
+ "\n",
+ "\n",
+ "#### <font color='blue'>**Datei-Streams**</font>\n",
+ "\n",
+ "Dateistreams sind in der Bibliothek `fstream` enthalten. \n",
+ "Sie ermöglichen das Lesen von und Schreiben in Dateien in ähnlicher Weise wie `cin` und `cout`. \n",
+ "Alles, was über Eingabe und Ausgabe besprochen wurde, gilt auch für Dateiströme.\n",
+ "In C++ gibt es drei Arten von Dateistreams: `ifstream`, `ofstream` und `fstream`. \n",
+ "Die ersten beiden werden verwendet nur für die Eingabe oder nur für die Ausgabe verwendet, \n",
+ "während `fstream` sowohl für die Eingabe als auch für die Ausgabe verwendet werden kann.\n",
+ "Ist der Name der Datei bekannt, kann ein zugehöriger Dateistrom deklariert werden als\n",
+ "\n",
+ "```c++\n",
+ "fstream datastream(\"daten.txt\");\n",
+ "```\n",
+ "\n",
+ "Wenn der Dateiname nicht im Voraus bekannt ist, kann der Stream zuerst deklariert und dann später geöffnet werden, als \n",
+ "\n",
+ "```c++\n",
+ "fstream datastream;\n",
+ " ... \n",
+ "datastream.open(\"daten.txt\");\n",
+ "```\n",
+ "\n",
+ "Diese Syntax wird normalerweise zum Öffnen einer Eingabedatei verwendet. \n",
+ "Die Syntax, die dem Zugriffsmodus 'w' von Python entspricht, lautet\n",
+ "\n",
+ "```c++\n",
+ "fstream datastream(\"daten.txt\", ios::out);\n",
+ "```\n",
+ "\n",
+ "Der **Append-Modus** kann durch die Verwendung von `ios::app` anstelle von `ios::out` angegeben werden.\n",
+ "\n",
+ "#### <font color='blue'>**String-Streams**</font>\n",
+ "\n",
+ "Eine Stringstream-Klasse, die in der `sstream`-Bibliothek enthalten ist, ermöglicht es, die Formatierungswerkzeuge zu verwenden, um eine **internen String** statt einer externen Ausgabe zu erzeugen. Im Wesentlichen dient ein solcher Stream als Puffer, um mit den Stream-Operatoren Daten in den Puffer zu schreiben oder Daten aus dem Puffer zu extrahieren. \n",
+ "\n",
+ "Einen int-Wert in einen String zu konvertieren, lässt sich mit einem `stringstream` wie folgt bewerkstelligen:\n",
+ "\n",
+ "```c++\n",
+ "stringstream temp;\n",
+ "temp << i; // Einfügen der Integer-Darstellung in den Stream\n",
+ "temp >> s; // Extrahieren des resultierenden Strings aus dem Stream\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "65d88e0b-1ba0-4e24-9054-5a03d7b7148e",
+ "metadata": {},
+ "source": [
+ "### <font color='blue'>**Klassen in C++**</font>\n",
+ "\n",
+ "#### <font color='blue'>**Definition einer Klasse**</font>\n",
+ "\n",
+ "Um die Syntax für eine C++-Klasse zu demonstrieren, wird mit einer einfachen Version der Klasse Point begonnen.\n",
+ "Beim Vergleich der C++-Syntax mit der von Python gibt es mehrere wichtige Aspekte zu besprechen. \n",
+ "\n",
+ "#### <font color='blue'>**Explizite Deklaration von Datenelementen**</font>\n",
+ "\n",
+ "Das Problem der statischen Typisierung tritt in einer Klassendefinition in den Vordergrund, da alle Datenelemente explizit deklariert werden müssen. \n",
+ "In Python werden die Attribute einer Klasse einfach durch Zuweisungsanweisungen im Körper des Konstruktors eingeführt. \n",
+ "In unserem C++-Beispiel wird der Typ der beiden Datenelemente in den Zeilen 3 und 4 explizit deklariert.\n",
+ "\n",
+ "```c++\n",
+ "1 class Point {\n",
+ "2 private:\n",
+ "3 double x;\n",
+ "4 double y;\n",
+ "5\n",
+ "6 public:\n",
+ "7 Point( ) : x(0), y(0) { }\n",
+ "8\n",
+ "9 double getX( ) const {\n",
+ "10 return x;\n",
+ "11 }\n",
+ "12\n",
+ "13 void setX(double val) {\n",
+ "14 x = val;\n",
+ "15 }\n",
+ "16\n",
+ "17 double getY( ) const { \n",
+ "18 return y;\n",
+ "19 }\n",
+ " ... \n",
+ "```\n",
+ "\n",
+ "#### <font color='blue'>**Konstruktor**</font>\n",
+ "\n",
+ "Zeile 7 unseres Codes findet sich der **Konstruktor**. Die Zeile beginnt mit dem Namen der Klasse selbst (d.h. Point), gefolgt von Klammern. Der Konstruktor ist eine Funktion, wobei dieses Beispiel keinen Parameter annimmt. Im Gegensatz zu anderen Funktionen gibt es jedoch keinen Rückgabewert in der Signatur (nicht einmal `void`).\n",
+ "\n",
+ "Der nächste Teil der Syntax ist der Doppelpunkt, gefolgt von x(0), y(0). Dies ist als sogenannte **Initialisierungsliste** in C++ bekannt. Es ist der bevorzugte Weg, um Anfangswerte für die Attribute festzulegen (wir dürfen keine Anfangswerte in den Zeilen 3 und 4 setzen). \n",
+ "Schließlich sehen wir die Syntax `{ }` für den eigentlich Rumpf des Konstruktors. \n",
+ "\n",
+ "Einige Klassen verwenden den Konstruktor-Rumpf, um kompliziertere Initialisierungen durchzuführen. \n",
+ "Im vorliegenden Fall, in dem beide Variablen bereits initialisiert wurden, gibt es für uns nichts weiter zu tun. \n",
+ "Aber die Klammern `{ }` dienen als syntaktischer Platzhalter (ähnlich wie `pass` in Python).\n",
+ "\n",
+ "#### <font color='blue'>**Implizite Selbstreferenz**</font>\n",
+ "\n",
+ "Es gibt einen wesentlichen Unterschied zwischen der Klassendefinition in C++ und in Python. \n",
+ "Die Selbst-Referenz `self` erscheint weder als formaler Parameter noch wird sie beim Zugriff auf die Attribute der Instanz verwendet. \n",
+ "`x` und `y` sind explizit als Attribute eines Punktes deklariert. Aus diesem Grund erkennt der Compiler diese Bezeichnungen, wenn sie im Rumpf unserer Methoden verwendet werden (zum Beispiel in Zeile 9). \n",
+ "Die die **Selbst-Referenz** ist in C++ implizit vorhanden und wird allerdings mit `this` bezeichnet. \n",
+ "Dies kann zum Beispiel nützlich sein, wenn wir unser Objekt als Parameter an eine externe Funktion übergeben. \n",
+ "\n",
+ "#### <font color='blue'>**Zugriffskontrolle**</font>\n",
+ "\n",
+ "Eine weitere Unterscheidung ist die Verwendung der Begriffe `public` und `private` in der Klassendefinition. \n",
+ "Diese beziehen sich auf den Aspekt der **Kapselung**. \n",
+ "\n",
+ "`public` Aspekte sind diejenigen, auf die sich andere Programmierer als feste äußere Schnittstelle verlassen können, \n",
+ "während `private` Aspekte interne Implementierungsdetails umfassen, die sich auch mal ändern können. \n",
+ "**Python** setzt diese Unterscheidung jedoch nicht strikt durch.\n",
+ "Stattdessen verlassen wir uns auf eine Namenskonvention und verwenden beispielweise Bezeichner, die mit einem Unterstrich beginnen (z.B.`_x`), \n",
+ "um die Privatsphäre zu erzeugen.\n",
+ "In C++ dienen diese Bezeichner dazu, die gewünschte **Zugriffskontrolle** für die verschiedenen Mitglieder zu deklarieren sowohl für Datenattribute als auch für Methoden. Die Verwendung des Begriffs `private` in Zeile 2 wirkt sich auf die nachfolgenden Deklarationen in Zeilen 3 und 4, während sich der Begriff `public` in Zeile 6 auf die nachfolgenden Deklarationen auswirkt. \n",
+ "Der Compiler erzwingt diese Auszeichnungen im Rest des Projektes und stellt sicher, dass auf die `private` Attribute von anderem Code nicht direkt zugegriffen werden kann.\n",
+ "\n",
+ "#### <font color='blue'>**Accessor versus Mutator**</font>\n",
+ "\n",
+ "In Python wird der Begriff des **Accessor**s für eine Methode verwendet, die den Zustand eines Objekts nicht verändert und auf Attribute oder abgelietet Größen zurückliefert und einen **Mutator** als eine Methode, die den Zustand verändern kann. \n",
+ "Diese Unterscheidung wird in C++ formalisiert, indem man explizit das Schlüsselwort `const` für Accessors am Ende der Funktionssignatur, aber vor dem Rumpf platziert wird. \n",
+ "In unserem Beispiel, sehen wir diesen Begriff in der Signatur von `getX` in Zeile 9 und erneut für `getY` in Zeile 13. \n",
+ "Auf eine solche Deklaration für die Mutatoren `setX` und `setY` wird zwangsläufig verzichtet.\n",
+ "Wie bei der Zugriffskontrolle werden diese `const`-Deklarationen später vom Compiler erzwungen. \n",
+ "Wenn eine Methode als `const` deklariert wird und versucht wird, eine Aktion mit Veränderung der Attribute durchzuführen, führt dies zu einem Kompilierzeitfehler. \n",
+ "Wenn ein Aufrufer ein Objekt hat, das als unveränderlich (immutable) deklariert wurde, sind die einzigen Methoden, die mit diesem Objekt aufgerufen werden können, diejenigen, die mit der `const`-Deklaration versehen sind.\n",
+ "\n",
+ "#### <font color='blue'>**Erweiterte Klasse Point**</font>\n",
+ "\n",
+ "Um einige zusätzliche Aspekte über eine Klassendefinition zu vermitteln, ist nun eine robustere Implementierung einer Punktklasse Gegenstand. \n",
+ "\n",
+ "In **Python** könnte man einen Konstruktor mit der folgenden Signatur deklarieren: \n",
+ "\n",
+ "```python \n",
+ "def init (self, initialX=0, initialY=0). \n",
+ "```\n",
+ "\n",
+ "Dies bietet Flexibilität, dass ein Aufrufer die Anfangskoordinaten für den Punkt festzulegen kann, oder aber den Ursprung als Standard verwenden kann. Die **C++-Version** dieses Konstruktors findet sich in Zeilen 7 und 8.\n",
+ "\n",
+ "```c++ \n",
+ " 1 class Point {\n",
+ " 2 private:\n",
+ " 3 double _x;\n",
+ " 4 double _y;\n",
+ " 5\n",
+ " 6 public:\n",
+ " 7 Point( double initialX=0.0, double initialY=0.0 )\n",
+ " 8 : _x(initialX), _y(initialY) { }\n",
+ " 9\n",
+ "10 double getX( ) const {\n",
+ "11 return _x;\n",
+ "12 }\n",
+ "13\n",
+ "14 void setX(double val) {\n",
+ "15 _x = val;\n",
+ "16 }\n",
+ "17\n",
+ "18 double getY( ) const {\n",
+ "19 return _y;\n",
+ "20 }\n",
+ "21\n",
+ "22 void setY(double val) {\n",
+ "23 _y = val;\n",
+ "24 }\n",
+ "25\n",
+ "26 void scale(double factor) {\n",
+ "27 _x *= factor;\n",
+ "28 _y *= factor;\n",
+ "29 }\n",
+ "30\n",
+ "31 double distance(Point other) const {\n",
+ "32 double dx = _x − other._x;\n",
+ "33 double dy = _y − other._y;\n",
+ "34 return sqrt(dx * dx + dy * dy); /* sqrt importiert aus der cmath library */\n",
+ "35 }\n",
+ "36\n",
+ "37 void normalize( ) {\n",
+ "38 double mag = distance( Point( ) );\n",
+ "39 if (mag > 0)\n",
+ "40 scale(1/mag);\n",
+ "41 }\n",
+ "42\n",
+ "43 Point operator+(Point other) const {\n",
+ "44 return Point( _x + other._x, _y + other._y);\n",
+ "45 }\n",
+ "46\n",
+ "47 Point operator*(double factor) const {\n",
+ "48 return Point( _x * factor,_y * factor);\n",
+ "49 }\n",
+ "50\n",
+ "51 double operator*(Point other) const {\n",
+ "52 return _x * other._x + _y * other._y;\n",
+ "53 }\n",
+ "54 }; // Ende der Point-Klasse (Semikolon erforderlich)\n",
+ "55 // Freistehende Operator-Deï¬nitionen, außerhalb der formalen Punktklassen-Deï¬nition\n",
+ "56 Point operator*(double factor, Point p) {\n",
+ "57 return p * factor; // Aufruf einer bestehenden Form mit Point als linkem Operanden\n",
+ "58 }\n",
+ "59\n",
+ "60 ostream& operator<<(ostream& out, Point p) {\n",
+ "61 out << \"<\" << p.getX( ) << \",\" << p.getY( ) << \">\"; // Anzeige mit Form <x,y>\n",
+ "62 return out;\n",
+ "63 }\n",
+ "``` \n",
+ "\n",
+ "Zunächst nochmal der Hinweis, dass explizit kein Selbstverweis notwendig ist. Dies wurde bereits durch die Verwendung von Namen wie `_x` anstelle von Pythons `self._x` deutlich gemacht. \n",
+ "Die gleiche Konvention wird verwendet, wenn der Körper einer **Mitgliedsfunktion** eine andere aufruft. In Zeile 40 sehen wir einen Aufruf der `scale`-Methode. Diese wird implizit für die aktuelle Instanz aufgerufen. In Zeile 38 erfolgt ein ähnlicher Aufruf der `distance`-Methode. Beachten Sie die Verwendung von `Point( )` in Zeile 38, um einen neuen (Standard-)Punkt als Parameter für die distance-Funktion zu instanziieren; dies ist derselbe Stil, den wir in Python verwendet haben.\n",
+ "\n",
+ "Die Zeilen 43-45 dienen der Unterstützung des Operators `+`, der die **Addition** von zwei Punkten ermöglicht. Dieses Verhalten ähnelt der `add`-Methode in Python, obwohl in C++ die Semantik mit `operator+` als Name einer Methode definiert wird. Im Fall der Syntax `p + q` dient der Punkt `p` als implizite Instanz\n",
+ "mit der diese Methode aufgerufen wird, während `q` als Parameter in der Signatur erscheint. \n",
+ "Die `const`-Deklaration in Zeile 43 bedeutet, dass der Zustand von `p` von dem Rumpf unberührt bleibt.\n",
+ "Die Zeilen 47-53 unterstützen **zwei verschiedene Arten der Multiplikation**: die Multiplikation eines bestimmten Punktes mit einer numerischen Konstante und die Berechnung des Punktprodukts zweier Punkte. \n",
+ "Eine **Python-Implementierung** würde dies mit einer einzigen Funktionsdefinition erreichen, die einen Parameter akzeptiert. Intern müsste eine dynamische Typüberprüfung dieses Parameters durchgeführt werden und das entsprechende Verhalten ausgeführt werden, je nachdem, ob der zweite Operand ein Punkt oder eine Zahl ist. Im C++-Beispiel gibt es zwei verschiedene Implementierungen. \n",
+ "Die erste akzeptiert ein `double`-Wert und gibt einen neuen `Point` zurück; die zweite akzeptiert einen `Point` und gibt einen `double`-Wert zurück. Die Bereitstellung von zwei separaten Deklarationen einer Methode wird als Überladen der Signatur bezeichnet. Da alle Daten explizit typisiert sind, kann C++ zur Kompilierzeit anhand der aktuellen Parameter bestimmen, welche der beiden Formen aufgerufen werden soll. \n",
+ "\n",
+ "Mit Zeile 54 endet die Deklaration der Klasse `Point`. \n",
+ "Wir bieten jedoch zwei unterstützende Definitionen an. Die erste davon unterstützt die Verwendung einer Syntax wie `3 * p`. Die frühere Definition von `operator*` aus den Zeilen 36-38 unterstützt technisch den Operator `*`, wenn eine `Point`-Instanz der **linke Operator** ist (z.B. `p * 3`). \n",
+ "C++ erlaubt es nicht, dass die formale Klassendefinition das Verhalten des Operators beeinflusst, wenn die einzige Instanz dieser Klasse der **rechte Operator** ist. Stattdessen definieren wir ein solches Verhalten unabhängig von der offiziellen Klassendefinition. In den Zeilen 56-58 definieren wir, wie sich `*` verhalten soll, wenn der erste Operator ein `double` und der zweite ein `Point` ist. Beide Operanden erscheinen jetzt in dieser Signatur als formale Parameter, da wir uns nicht mehr im Kontext der Klassendefinition befinden. Der Rumpf unserer Methode wendet den einfachen Trick an, indem er die Reihenfolge umkehrt, so dass der Punkt der linke Operand wird (und damit unsere zuvor definierte Version aufruft).\n",
+ "\n",
+ "Die Zeilen 60-62 schließlich dienen dazu, eine Textdarstellung eines Punktes zu erzeugen, wenn dieser in einen Ausgabestrom eingefügt wird, z.B. bei `cout << p`. Auch hier wird dieses Verhalten außerhalb des Kontexts der Klasse definiert, da der Punkt als rechter Operator dient. Zeile 61 fügt die gewünschte Ausgabedarstellung in den angegebenen Ausgabestrom ein. Als formalen Parameter wird `out` anstelle von `cout` verwendet, damit ein Benutzer dieses Verhalten auf jede Art von Ausgabestrom anwenden kann. Der deklarierte Rückgabetyp in Zeile 60 und die Return-Anweisung in Zeile 62 sind syntaktisch erforderlich, um mehrere `<<`-Operationen in einer Zeile zu ermöglichen. Die Syntax `cout << p << \" ist gut\"` wird als `(cout << p) << \" ist gut\"` ausgewertet, wobei das Ergebnis der ersten Auswertung ein Ausgabestrom ist, der in der zweiten Operation verwendet wird. Die zweimalige Verwendung des Symbols `&` in Zeile 60 ist eine weitere Besonderheit, die zu unserem nächsten Abschnitt führt.\n",
+ "\n",
+ "#### <font color='blue'>**Vererbung**</font>\n",
+ "\n",
+ "Im Folgenden werden zwei Beispiele zum Thema Verebrung in C++ dargestellt. Zuerst deï¬nieren wir eine `DeluxeTV`-Klasse, die ein SortedSet verwendet. Die vorausgesetzte Definition für eine einfache Fernsehklasse wird hier weglassen. Die Verwendung der Vererbung für die DeluxeTV-Klasse wird ursprünglich in Zeile 1 angezeigt, indem nach der Deklaration der neuen Klasse mit einem Doppelpunkt und dann dem Ausdruck `public Television`. Mit dieser Bezeichnung, erbt die `DeluxeTV`-Klasse sofort alle Attribute (z.B. `powerOn`, `channel`) und alle Methoden (z.B. `setChannel`) von der Elternklasse. Zusätzlich werden weitere Attribute deï¬niert bzw. neue oder aktualisierte Implementierungen für Methoden hinzugefügt. \n",
+ "\n",
+ "```c++\n",
+ " 1 class DeluxeTV : public Television {\n",
+ " 2 protected:\n",
+ " 3 set<int> _favorites;\n",
+ " 4\n",
+ " 5 public:\n",
+ " 6 DeluxeTV( ) :\n",
+ " 7 Television( ), // Eltern Konstruktor\n",
+ " 8 _favorites( ) // leeres Set als Default\n",
+ " 9 { }\n",
+ "10\n",
+ "11 void addToFavorites( ) { if (_powerOn) _favorites.insert(_channel); }\n",
+ "12\n",
+ "13 void removeFromFavorites( ) { if (_powerOn) _favorites.erase(_channel); }\n",
+ "14\n",
+ "15 int jumpToFavorite( ) {\n",
+ "16 if (_powerOn && _favorites.size( ) > 0) {\n",
+ "17 set<int>::iterator result = _favorites.upper_bound(_channel);\n",
+ "18 if (result == _favorites.end( ))\n",
+ "19 result = _favorites.begin( );\n",
+ "20 setChannel(*result);\n",
+ "21 }\n",
+ "22 return _channel;\n",
+ "23 }\n",
+ "24 }; // Ende von DeluxeTV\n",
+ "``` \n",
+ "\n",
+ "In Zeile 3 deklarieren wir ein neues Attribut zur Verwaltung des Sets der bevorzugten Kanalnummern. \n",
+ "Es soll besonders auf die Verwendung des Wortes `protected` in Zeile 2 aufmerksam gemacht werden. \n",
+ "Bis jetzt haben wir zwei Formen der Zugriffskontrolle verwendet: `public` und `privat`. \n",
+ "Auf Mitglieder, die `public` sind, kann von Code außerhalb der Klassendefinition zugegriffen werden, während auf Mitglieder, die `private` sind, nur innerhalb der ursprünglichen Klassendefinition zugegriffen werden kann. \n",
+ "Der Zweck der Privatheit besteht darin, interne Implementierungsdetails zu kapseln auf die sich andere nicht verlassen sollten. Durch die Vererbung ist jedoch eine dritte Zugriffsebene erforderlich. Wenn eine Klasse von einer anderen erbt, stellt sich die Frage, ob der Code der Kindklasse Zugriff auf die von der Elternklasse geerbten Mitglieder haben sollte. Dies wird bestimmt durch die Zugriffskontrolle, die von der Elternklasse festgelegt wurde. Eine untergeordnete Klasse kann nicht direkt auf Mitglieder zugreifen, die die von der Elternklasse als `private` deklariert wurden. Die untergeordnete Klasse hat jedoch Zugriff auf Attribute, die von der Elternklasse als `proteced` eingestuft sind.\n",
+ "In diesem speziellen Fall ist der wichtige Punkt nicht unsere Verwendung von `protected` in Zeile 2.\n",
+ "Hier ist wichtig, wie die ursprünglichen Attribute der Klasse `Television` deï¬niert wurden. \n",
+ "Damit unser `DeluxeTV`-Code funktioniert, müssen die `Television`-Attribute wie folgt ursprünglich deklariert worden sein: \n",
+ "\n",
+ "```c++\n",
+ " protected:\n",
+ " bool _powerOn;\n",
+ " int _channel;\n",
+ " ...\n",
+ "```\n",
+ "Wären diese als `private` deklariert worden, könnten wir nicht auf sie zugreifen, um unser `DeluxeTV` zu implementieren. Der ursprüngliche Designer des `Television` hat vielleicht nicht gewusst, dass wir auftauchen würden kommen und von ihm erben wollen, aber ein erfahrener C++-Programmierer wird diese Möglichkeit beim Entwurf eine Klasse berücksichtigen. In unserer `DeluxeTV`-Definition dient die Deklaration des Attributs `_favorites` als `protected`, um die Möglichkeit offen zu lassen, dass jemand anderes eines Tages ein `SuperDeluxeTV` entwirft. Als Alternative zu `protected` Daten kann eine Elternklasse auch `protected` Methoden bereitstellen, um den `private` Zustand zu kapseln.\n",
+ "\n",
+ "Ein zweiter Aspekt unseres Beispiels, ist die Definition unseres Konstruktors in den Zeilen 6-9. In einer Python-Version beginnt der neue Konstruktor mit einem expliziten Aufruf des übergeordneten Konstruktors, der die Syntax `Television.__init__(self)` verwendet. \n",
+ "Dies wurde verwendet, um die Standardeinstellungen für alle geerbten Attribute festzulegen. \n",
+ "\n",
+ "In C++ kann man den Aufruf des Konstruktors der Elternklasse als Teil der **Initialisierungsliste** mit der Syntax `Television( )` in Zeile 7 aufnehmen. Hier wird der übergeordnete Konstruktor aufgerufen, ohne dass explizite Parameter übergeben werden. \n",
+ "Eigentlich ist Zeile 7 in diesem speziellen Beispiel überflüssig. \n",
+ "Wenn der übergeordnete Konstruktor nicht explizit aufgerufen wird, wird C++ dies implizit tun. \n",
+ "Ein expliziter Aufruf ist jedoch erforderlich, wenn Parameter an den übergeordneten Konstruktor gesendet werden sollen (wie in unserem zweiten Beispiel). In diesem Beispiel ist auch unsere Standardinitialisierung der `_favorites` in Zeile 8 überflüssig. \n",
+ "\n",
+ "Die Zeilen 11-23 des `DeluxeTV`-Codes bieten drei neue Verhaltensweisen. \n",
+ "Die genauen Details dieser Methoden hängen von der Kenntnis der `Set`-Klasse ab. \n",
+ "Daher werden die Methoden hier noch nicht aufgegriffen. Wir weisen darauf hin, dass wir bei der Implementierung der Methoden sowohl auf die geerbten Attribute `_powerOn` und `_channel` als auch auf unser neues Attribut `_favorites` zugreifen können. Wir rufen auch die geerbte Methode `setChannel` auf.\n",
+ "\n",
+ "##### <font color='blue'>**Square-Klasse**</font>\n",
+ "\n",
+ "Als zweites Beispiel für Vererbung dient eine Klasse `Square`. \n",
+ "Die Klasse Square erbt von einer angenommenen Klasse `Rectangle`. \n",
+ "Es werden keine neuen Attribute für diese Klasse eingeführt, \n",
+ "so dass unsere einzige Verantwortung für den Konstruktor darin besteht, \n",
+ "sicherzustellen dass die geerbten Attribute **richtig initialisiert** sind. \n",
+ "Zu diesem Zweck wird der übergeordnete Konstruktor in Zeile 4 aufgerufen. \n",
+ "In diesem Fall wird der expliziten Aufruf benötigt, um die entsprechenden Dimensionen und den Mittelpunkt zu übergeben. \n",
+ "Geschieht das nicht, wäre ein impliziter Aufruf an die Standardversion des Rechteck-Konstruktors erfolgt, was zu einer falschen Semantik für das Quadrat geführt hätte.\n",
+ "\n",
+ "```c++\n",
+ " 1 class Square : public Rectangle {\n",
+ " 2 public:\n",
+ " 3 Square(double size=10, Point center=Point( )) :\n",
+ " 4 Rectangle(size, size, center) // Eltern Konstruktor\n",
+ " 5 { }\n",
+ " 6\n",
+ " 7 void setHeight(double h) { setSize(h); }\n",
+ " 8 void setWidth(double w) { setSize(w); }\n",
+ " 9\n",
+ "10 void setSize(double size) {\n",
+ "11 Rectangle::setWidth(size); // sicher stellen, dass die PARENT-Version aufrufen wird\n",
+ "12 Rectangle::setHeight(size); // sicher stellen, dass die PARENT-Version aufrufen wird\n",
+ "13 }\n",
+ "14\n",
+ "15 double getSize( ) const { return getWidth( ); }\n",
+ "16 }; // Ende der Square-Klasse\n",
+ "```\n",
+ "\n",
+ "Der Rest der Definition dient dazu, neue `getSize`- und `setSize`-Methoden bereitzustellen, während die bestehenden Methoden `setHeight` und `setWidth` zu überschreiben sind, so dass eine Änderung einer der beiden Dimensionen sich auf beide auswirkt.\n",
+ "Die vorhandenen Methoden in den Zeilen 7 und 8 werden überschrieben, um die neue `setSize`-Methode aufzurufen. Unsere `setSize`-Methode stützt sich dann auf die übergeordneten Versionen der überschriebenen Methoden `setWidth` und `setHeight`, um die einzelnen Änderungen an diesen Werten vorzunehmen. \n",
+ "Der Ausdruck `Rectangle::` vor den Methodennamen in den Zeilen 11 und 12 ist eine Bereichsauflösung (scope resolution) und zeigt an, dass die Methoden der übergeordneten Klasse `Rectangle` und nicht die Klasse `Square` aufgerufen werden."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "eb8cc3c4-a06f-4676-95e5-a6243124c3c0",
+ "metadata": {},
+ "source": [
+ "### <font color='blue'>**Objektmodelle und Speicherverwaltung**</font>\n",
+ "\n",
+ "Python unterstützt ein konsistentes Modell, bei dem alle Referenzen von Natur aus **Verweise** auf zugrunde liegende Objekte sind. Die Verwendung des Zuweisungsoperators wie in `a = b` bewirkt, dass der Bezeichner `a` demselben zugrundeliegenden Objekt, auf das der Bezeichner `b` verweist, zugewiesen wird. \n",
+ "Diese Semantik wird konsistent auf alle Arten von Objekte angewandt. \n",
+ "Die Semantik der Zuweisung gilt auch für die Weitergabe von Informationen an und von einer Funktion. \n",
+ "Beim Aufruf einer **Funktion** werden die **formalen Parameter** jeweils den vom Aufrufer angegebenen Aktualparametern zugewiesen. Der Rückgabewert wird auf ähnlicher Weise übermittelt. \n",
+ "Nehmen wir als einfaches Beispiel an, dass wir die folgende Python-Funktion definieren, um festzustellen, ob ein gegebener Punkt mit dem Ursprung äquivalent ist:\n",
+ "\n",
+ "```python \n",
+ "def isOrigin(pt):\n",
+ " return pt.getX( ) == 0 and pt.getY( ) == 0\n",
+ "```\n",
+ "Wird diese Funktion mit `isOrigin(bldg)` aufgerufen, wobei der Bezeichner `bldg` auf eine `Point`-Instanz verweist. In diesem Szenario erfolgt eine implizite Zuweisung des Formalparameters `pt` zum aktuellen Parameter `pt = bldg`.\n",
+ "\n",
+ "Im folgenden werden die gleichen Aspekte in C++ behandelt, nämlich die Korrespondenz zwischen einem Bezeichner und dem dahinter liegenden Wert, die Semantik einer Zuweisungsoperation und die anschließende Auswirkung auf die Übergabe von Informationen an bzw. von einer Funktion. C++ bietet eine **feinere Steuerung** als Python und erlaubt dem Programmierer die Wahl zwischen **drei verschiedenen semantischen Modellen** für die Speicherung und Weitergabe von Informationen.\n",
+ "\n",
+ "\n",
+ "### <font color='blue'>**Wert-Variablen**</font>\n",
+ "\n",
+ "Das am häufigsten verwendete Modell in C++ ist das einer Wertvariablen. Deklarationen wie\n",
+ "\n",
+ "```c++\n",
+ "Point a;\n",
+ "Point b(5,7);\n",
+ "```\n",
+ "\n",
+ "**reserviert Speicher** für die neu erzeugten Punkte.\n",
+ "Da alle Datenelemente für einen `Point` explizit in der Klassendefinition deï¬niert werden, kann das System genau bestimmen, wie viel Speicher für jede Instanz benötigt wird. \n",
+ "Die Ãœbersetzung von einem Namen in eine bestimmte Instanz erfolgt zur Kompilierzeit, \n",
+ "was zu einer größeren Laufzeiteffizienz gegenüber der Abbildung zur Laufzeit bei Python.\n",
+ "\n",
+ "Die Zuweisungssemantik für eine Wertvariable unterscheidet sich stark von derjenigen in Python. Der Befehl `a = b` weist dem `Point` `a` den Wert zu, den der `Point b` gerade hat.\n",
+ "Beachten Sie, dass die Namen `a` und `b` immer noch **zwei verschiedene Punkte** repäsentieren.\n",
+ "Die Semantik von Wert-Variablen manifestiert sich auch in der Weitergabe von Informationen an und von einer Funktion. Betrachten wir das folgende C++-Analogon zu unserem Python-Beispiel.\n",
+ "\n",
+ "```c++\n",
+ "bool isOrigin(Point pt) {\n",
+ " return pt.getX( ) == 0 && pt.getY( ) == 0;\n",
+ "}\n",
+ "```\n",
+ "Wenn die Funktion mit `isOrigin(bldg)` aufgerufen wird, wird der formale Parameter `Point pt` **implizit initialisiert**, als ob die Syntax des Kopierkonstruktors verwendet würde,\n",
+ "```c++\n",
+ "Punkt pt(bldg);\n",
+ "```\n",
+ "Der formale Parameter `pt` wird nicht zu einem Alias für den eigentlichen Parameter. \n",
+ "Es ist eine **neue `Point`-Instanz**, deren Zustand so initialisiert ist, dass er mit dem des eigentlichen Parameters `bldg` übereinstimmt. \n",
+ "Daher haben Änderungen am Parameter im des Funktionsrumpf keine Auswirkung auf das Objekt des Aufrufers. Diese Art der Parameterübergabe wird allgemein als **pass-by-value** bezeichnet.\n",
+ "\n",
+ "### <font color='blue'>**Referenz-Variablen**</font>\n",
+ "\n",
+ "Ein zweites Modell für eine C++-Variable wird als Referenz-Variable bezeichnet. Sie wird deklariert als\n",
+ "\n",
+ "```c++\n",
+ "Punkt& c(a); // Referenzvariable\n",
+ "```\n",
+ "\n",
+ "Syntaktisch besteht der Unterschied in der Verwendung des kaufmännischen Und-Zeichens. \n",
+ "Dies kennzeichnet `c` als neuen Namen, aber es ist kein neuer `Point`. \n",
+ "Stattdessen wird er zu einem **Alias** für den bestehenden `Point a`. \n",
+ "\n",
+ "Dies kommt dem **Python-Modell** näher, ist aber immer noch nicht ganz dasselbe. \n",
+ "Eine C++-Referenz Variable muss bei der Deklaration an eine bestehende Instanz gebunden werden. \n",
+ "Sie kann nicht eine Referenz auf nichts sein sein (wie es in Python mit dem Wert None möglich ist). \n",
+ "Außerdem ist die Bindung der Referenzvariablen **statisch** in C++; \n",
+ "einmal deklariert, kann dieser Name nicht mehr mit einem anderen Objekt neu assoziiert werden.\n",
+ "Der Name `c` wird zu einem echten Alias für den Namen `a`. Die Zuweisung `c = b` bindet den Namen `c` nicht neu; dies ändert den Wert von `c` (auch bekannt als `a`).\n",
+ "\n",
+ "Referenzvariablen werden, wie oben gezeigt, nur selten verwendet, da es in einem lokalen Kontext wenig Bedarf für einen zweiten Namen für dasselbe Objekt besteht. \n",
+ "Die Semantik von Referenz-Variablen wird jedoch im **Kontext von Funktionen** extrem wichtig. Wir können eine **pass-by-reference**-Semantik verwenden, indem wir das kaufmännische Und in der Deklaration eines formalen Parameters verwenden, wie in der folgenden Überarbeitung von `isOrigin`\n",
+ "\n",
+ "```c++\n",
+ "bool isOrigin(Point& pt) {\n",
+ " return pt.getX( ) == 0 && pt.getY( ) == 0;\n",
+ "```\n",
+ "\n",
+ "Dies führt zu einem Modell ähnlich dem von Python, bei dem der **formale Parameter zu einem Alias für den tatsächlichen Parameter** wird. Diese Vorgehensweise hat mehrere Vorteile. \n",
+ "Bei größeren Objekten ist die Ãœbergabe die **Speicheradresse effizienter** als die Erstellung und Ãœbergabe einer Kopie des Objektwerts. Die Ãœbergabe per Referenz ermöglicht es einer Funktion auch, das **Objekt des Aufrufers zu manipulieren**. Wenn einer Funktion nicht erlaubt werden soll, ihre Parameter zu verändern, aber die Vorteile der Ãœbergabe per Referenz nutzen wollen, kann ein `const` Modiï¬er mit dem formalen Parameter deklariert werden, wie in\n",
+ "\n",
+ "```c++\n",
+ "bool isOrigin(const Point& pt) {\n",
+ " return pt.getX( ) == 0 && pt.getY( ) == 0;\n",
+ "}\n",
+ "```\n",
+ "Mit einer solchen Signatur wird der Punkt als Referenz übergeben, aber die Funktion verspricht, dass sie diesen Punkt in keiner Weise verändert.\n",
+ "\n",
+ "### <font color='blue'>**Zeiger-Variablen**</font>\n",
+ "\n",
+ "C++ unterstützt ein drittes Modell für Variablen, den sogenannten Zeiger. Die Semantik dieses Modells kommt **am ehesten dem Pythons Modell** am nächsten, aber die Syntax ist ganz anders. Eine C++-Zeigervariable wird wie folgt deklariert:\n",
+ "\n",
+ "```c++\n",
+ "Point *d; // d ist eine Zeigervariable\n",
+ "```\n",
+ "\n",
+ "Das Sternchen in diesem Kontext erklärt, dass `d` nicht selbst ein Point ist, sondern eine Variable, die die **Speicheradresse** eines `Points` speichern kann. Zeiger sind allgemeiner als Referenzvariablen, da ein Zeiger auf nichts zeigen darf (in C++ wird das Schlüsselwort NULL verwendet) und ein Zeiger dynamisch an die Adresse einer anderen Instanz zugewiesen werden kann. Eine typische Zuweisungsanweisung sieht folgendermaßen aus:\n",
+ "\n",
+ "```c++\n",
+ "d = &b;\n",
+ "```\n",
+ "\n",
+ "Wir stellen `d` absichtlich als separate Entität dar, weil es selbst eine im Speicher gespeicherte Variable ist, deren Wert zufällig eine Speicheradresse eines anderen Objekts ist. \n",
+ "Um den zugrundeliegenden Punkt mit dieser Variablen zu manipulieren, müssen wir sie explizit derefenzieren. \n",
+ "Während die Syntax `d` für einen Zeiger steht, steht die Syntax `*d` für das Objekt, das damit adressiert wird (als Gedächtnisstütze kann man sich die ursprüngliche Deklaration Point `*d` vorstellen, die suggeriert, dass `*d` ein Punkt ist). \n",
+ "Wir könnten zum Beispiel die Methode `(*d).getY( )` aufrufen, aufrufen, die in diesem Fall z.B. den Wert `7.0` zurückgibt. \n",
+ "Die Klammern sind wegen des Vorrangs der Operatoren notwendig. \n",
+ "Da diese Syntax sperrig ist, wird ein bequemerer Operator `->` unterstützt, mit der entsprechenden Syntax `d->getY( )`.\n",
+ "\n",
+ "Zeiger bieten dem C++-Programmierer mehrere zusätzliche Möglichkeiten. Ein Zeiger kann als Parameter an eine Funktion übergeben werden, wie in der folgenden Überarbeitung von `isOrigin` gezeigt wird.\n",
+ "\n",
+ "```c++\n",
+ "bool isOrigin(Point *pt) {\n",
+ " return pt−>getX( ) == 0 && pt−>getY( ) == 0;\n",
+ "}\n",
+ "```\n",
+ "\n",
+ "Technisch gesehen, deklarieren wir einen neuen lokalen Zeiger, dessen Wert auf den Wert des Zeigers gesetzt wird, der vom Aufrufer gesendet wurde. Infolgedessen hat der Funktionskörper indirekten Zugriff auf dasselbe zugrunde liegende Objekt, das der Zeiger adressiert. \n",
+ "Dies bietet ähnliche Möglichkeiten wie bei der **pass-by-value** Übergabe. Zusätzlich besteht die Möglichkeit, dass der Aufrufer einen NULL-Zeiger sendet. Der folgende Abschnitt wird eine weitere Verwendung von Zeigern in C++ vorgestellt, nämlich die Verwaltung dynamisch zugewiesener Objekte.\n",
+ "\n",
+ "### <font color='blue'>**Dynamisches Speichermanagement**</font>\n",
+ "\n",
+ "Bei **Wert-Variablen** kümmert sich C++ um alle Fragen der Speicherverwaltung. \n",
+ "Wenn eine Deklaration vorgenommen wird, wie z.B. `Point a`, reserviert das Laufzeitsystem Speicher für den Zustand des Objekts. \n",
+ "Wenn diese Variablendeklaration den Anwendungsbereich verlässt (z.B. wenn es sich um eine lokale Variable innerhalb eines Funktionskörpers handelt), **vernichtet** das Laufzeitsystem automatisch das Objekt und gibt den Speicher für andere Zwecke frei.\n",
+ "Im Allgemeinen entlastet diese automatische Speicherverwaltung den Computer.\n",
+ "\n",
+ "Es gibt jedoch Umstände, unter denen ein Programmierer eine aktivere Rolle bei der Steuerung der zugrundeliegenden Speicherverwaltung übernehmen möchte. \n",
+ "Zum Beispiel könnte eine Funktion ein oder mehrere Objekte erzeugen, die über den Kontext der Funktion hinaus im Speicher bleiben sollen. \n",
+ "In C++ wird eine solche dynamische Instanziierung mit dem **Schlüsselwort** `new` versehen wie z.B. `new Point` für die Standard-Konstruktion oder `new Point(5,7)` für eine Nicht-Standard-Konstruktion. \n",
+ "Formal gibt der `new` Operator die **Speicheradresse** zurück, an der das konstruierte Objekt gespeichert ist. \n",
+ "Um mit dem Objekt interagieren zu können, muss lokalisierbar sein. \n",
+ "Ein üblicher Ansatz ist die Verwendung einer **Zeiger-Variable** zu verwenden, um sich den Speicherort zu merken.\n",
+ "\n",
+ "```c++\n",
+ "Point *p; // Zeiger-Variable deklarieren (noch nicht initialisiert)\n",
+ "p = new Point( ); // dynamisch eine neue Point-Instanz allokieren und ihre Adresse speichern\n",
+ "```\n",
+ "\n",
+ "In diesem Codefragment werden zwei verschiedene Speicherbereiche verwendet. \n",
+ "Eine bestimmte Anzahl von Bits wird für die Verwaltung der **Zeiger-Variablen** `p` reserviert, während eine andere Gruppe von Bits für die Speicherung des Zustands der `Point`-Instanz reserviert ist. \n",
+ "Der wichtige Punkt ist, dass bei der dynamischen Zuweisung des `Point`s diese Instanz im Speicher verbleibt, selbst wenn die Variable `p` aus dem Geltungsbereich verschwindet. Dies hat die Rückforderung des Speichers für die Variable `p`, aber nicht des Objekts, auf das sie zeigt, zur Folge.\n",
+ "\n",
+ "Die Verwaltung von dynamisch zugewiesenen Objekten erfordert mehr Sorgfalt. \n",
+ "Wenn ein Programm die Kontrolle über den Speicherort von Objekten verliert (z.B. durch die Neuzuweisung einer Zeigervariablen an einen anderen Ort), verbleibt das ursprüngliche Objekt im Speicher, udn es ist aber nun unzugänglich. \n",
+ "Ein solcher Fehler ist bekannt als **Speicherleck**, und ein Programm, das weiterhin solche Objekte allokiert, ohne sie jemals wieder freizugeben verbraucht bei seiner Ausführung immer mehr Arbeitsspeicher des Computers. \n",
+ "In C++ hat der Programmierer die Aufgabe, ein dynamisch zugewiesenes Objekt explizit aus dem Speicher zu entfernen, wenn es nicht mehr benötigt wird.\n",
+ "Dies geschieht durch die Verwendung einer Syntax wie `delete p` für das obige Beispiel. \n",
+ "Der Ausdruck nach dem Schlüsselwort `delete` gibt die Adresse des zu löschenden Objekts an. \n",
+ "Allerdings darf `delete` nur auf Objekte angewendet werden, die **dynamisch** zugewiesen wurden. \n",
+ "Würden Sie die Adresse einer Wert-Variable angeben, tritt ein Fehler auf, wenn das System die automatische Deallokation versucht. \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_11/LSG_cpp.cpp b/Semester_2/Einheit_11/LSG_cpp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8bcca7e4edf99986e9a948a8cbfa857a33ffbbe4
--- /dev/null
+++ b/Semester_2/Einheit_11/LSG_cpp.cpp
@@ -0,0 +1,126 @@
+#include <iostream>
+
+using namespace std;
+
+class Moebel{
+ protected:
+ float laenge;
+ float hoehe;
+ float breite;
+ string farbe;
+
+ public:
+ Moebel(float, float, float, string);
+ float get_laenge();
+ float get_hoehe();
+ float get_breite();
+ string get_farbe();
+ void set_farbe(string);
+ void info();
+};
+
+Moebel::Moebel(float laenge, float hoehe, float breite, string farbe){
+ this->laenge = laenge;
+ this->breite = breite;
+ this->hoehe = hoehe;
+ this->farbe = farbe;
+}
+
+float Moebel::get_laenge(){
+ return laenge;
+}
+
+float Moebel::get_hoehe(){
+ return hoehe;
+}
+
+float Moebel::get_breite(){
+ return breite;
+}
+
+string Moebel::get_farbe(){
+ return farbe;
+}
+
+void Moebel::set_farbe(string f){
+ farbe = f;
+}
+
+void Moebel::info(){
+ cout << "Das Moebelstueck ist " << laenge << " cm lang, " << hoehe << " cm hoch, "<< breite << " cm breit und hat die Farbe " << farbe << "." << endl;
+}
+
+
+
+
+
+class Schrank:public Moebel{
+ private:
+ bool spiegel;
+ int n_tueren;
+
+ public:
+ Schrank(float, float, float, string, bool, int);
+ bool get_spiegel();
+ int get_n_tueren();
+ void info();
+ Schrank operator+(Schrank&);
+};
+
+Schrank::Schrank(float l, float h, float b, string f, bool s, int n_t):Moebel(l, h, b, f){
+ spiegel = s;
+ n_tueren = n_t;
+}
+
+bool Schrank::get_spiegel(){
+ return spiegel;
+}
+
+int Schrank::get_n_tueren(){
+ return n_tueren;
+}
+
+void Schrank::info(){
+ if(spiegel){
+ cout << "Der Schrank ist " << laenge << " cm lang, " << hoehe << " cm hoch, "<< breite << " cm breit, "<< farbe << ", hat " << n_tueren << " Tueren und Spiegel."<< endl;
+ }
+ else{
+ cout << "Der Schrank ist " << laenge << " cm lang, " << hoehe << " cm hoch, "<< breite << " cm breit, "<< farbe << ", hat " << n_tueren << " Tueren und Spiegel."<< endl;
+ }
+}
+
+Schrank Schrank::operator+(Schrank& s2){
+ float h(hoehe);
+ float b(breite);
+ string f(farbe);
+
+ if (s2.get_hoehe() > hoehe) h=s2.get_hoehe();
+ if (s2.get_breite() > breite) b=s2.get_breite();
+ if (s2.get_farbe() != farbe) f="mehrfarbig";
+
+ return Schrank(laenge + s2.get_laenge(), h, b, f, spiegel || s2.get_spiegel(), n_tueren + s2.get_n_tueren());
+ }
+
+
+
+int main(){
+
+ cout << "Test: Klasse Moebel:" << endl;
+ Moebel m1(100, 80, 40, "blau");
+ m1.info();
+ cout << "Hoehe von m1: " << m1.get_hoehe() << " cm." << endl;
+
+ m1.set_farbe("schwarz");
+ m1.info();
+
+ cout << "\n\nTest: Klasse Schrank:" << endl;
+ Schrank s1(100, 180, 60, "weiss", true, 2);
+ s1.info();
+ Schrank s2(60, 200, 60, "weiss", false, 1);
+ s2.info();
+ (s1+s2).info();
+ s2.set_farbe("schwarz");
+ (s1+s2).info();
+
+ return 0;
+}
\ No newline at end of file
diff --git a/Semester_2/Einheit_11/Pics/Compiler.png b/Semester_2/Einheit_11/Pics/Compiler.png
new file mode 100644
index 0000000000000000000000000000000000000000..e280582cec506b6df0342d9bfab91b28254c4df9
Binary files /dev/null and b/Semester_2/Einheit_11/Pics/Compiler.png differ
diff --git a/Semester_2/Einheit_11/Pics/Interpreter.png b/Semester_2/Einheit_11/Pics/Interpreter.png
new file mode 100644
index 0000000000000000000000000000000000000000..1c4172e89ed1e95067fcf04d22bed114c9f95166
Binary files /dev/null and b/Semester_2/Einheit_11/Pics/Interpreter.png differ
diff --git a/Semester_2/Einheit_11/Pics/Sprachen.png b/Semester_2/Einheit_11/Pics/Sprachen.png
new file mode 100644
index 0000000000000000000000000000000000000000..f37d7c3fc0184d39a088450ef3d7ec086d39ff71
Binary files /dev/null and b/Semester_2/Einheit_11/Pics/Sprachen.png differ
diff --git a/Semester_2/Einheit_11/Pics/UML_Moebel_Schrank.svg b/Semester_2/Einheit_11/Pics/UML_Moebel_Schrank.svg
new file mode 100644
index 0000000000000000000000000000000000000000..6229841da4201e0de329d0800ee9605e52a34a0f
--- /dev/null
+++ b/Semester_2/Einheit_11/Pics/UML_Moebel_Schrank.svg
@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="windows-1252" standalone="no"?>
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" contentStyleType="text/css" height="463px" preserveAspectRatio="none" style="width:354px;height:463px;background:#FFFFFF;" version="1.1" viewBox="0 0 354 463" width="354px" zoomAndPan="magnify"><defs/><g><!--class Moebel--><g id="elem_Moebel"><rect codeLine="1" fill="#F1F1F1" height="227.2656" id="Moebel" rx="2.5" ry="2.5" style="stroke:#181818;stroke-width:0.5;" width="272" x="41" y="7"/><ellipse cx="146.25" cy="23" fill="#ADD1B2" rx="11" ry="11" style="stroke:#181818;stroke-width:1.0;"/><path d="M148.5938,18.6719 C147.6563,18.2344 147.0625,18.0938 146.1875,18.0938 C143.5625,18.0938 141.5625,20.1719 141.5625,22.8906 L141.5625,24.0156 C141.5625,26.5938 143.6719,28.4844 146.5625,28.4844 C147.7813,28.4844 148.9375,28.1875 149.6875,27.6406 C150.2656,27.2344 150.5938,26.7813 150.5938,26.3906 C150.5938,25.9375 150.2031,25.5469 149.7344,25.5469 C149.5156,25.5469 149.3125,25.625 149.125,25.8125 C148.6719,26.2969 148.6719,26.2969 148.4844,26.3906 C148.0625,26.6563 147.375,26.7813 146.6094,26.7813 C144.5625,26.7813 143.2656,25.6875 143.2656,23.9844 L143.2656,22.8906 C143.2656,21.1094 144.5156,19.7969 146.25,19.7969 C146.8281,19.7969 147.4375,19.9531 147.9063,20.2031 C148.3906,20.4844 148.5625,20.7031 148.6563,21.1094 C148.7188,21.5156 148.75,21.6406 148.8906,21.7656 C149.0313,21.9063 149.2656,22.0156 149.4844,22.0156 C149.75,22.0156 150.0156,21.875 150.1875,21.6563 C150.2969,21.5 150.3281,21.3125 150.3281,20.8906 L150.3281,19.4688 C150.3281,19.0313 150.3125,18.9063 150.2188,18.75 C150.0625,18.4844 149.7813,18.3438 149.4844,18.3438 C149.1875,18.3438 148.9844,18.4375 148.7656,18.75 L148.5938,18.6719 Z " fill="#000000"/><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacing" textLength="53" x="166.75" y="27.8467">Moebel</text><line style="stroke:#181818;stroke-width:0.5;" x1="42" x2="312" y1="39" y2="39"/><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacing" textLength="87" x="47" y="55.9951">laenge:float</text><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacing" textLength="84" x="47" y="72.292">hoehe:float</text><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacing" textLength="84" x="47" y="88.5889">breite:float</text><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacing" textLength="86" x="47" y="104.8857">farbe:string</text><line style="stroke:#181818;stroke-width:0.5;" x1="42" x2="312" y1="112.1875" y2="112.1875"/><text fill="#000000" font-family="sans-serif" font-size="14" font-style="italic" lengthAdjust="spacing" textLength="82" x="47" y="129.1826">Konstruktor</text><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacing" textLength="178" x="129" y="129.1826">(float, float, float, string)</text><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacing" textLength="129" x="47" y="145.4795">get_laenge():float</text><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacing" textLength="126" x="47" y="161.7764">get_hoehe():float</text><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacing" textLength="126" x="47" y="178.0732">get_breite():float</text><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacing" textLength="128" x="47" y="194.3701">get_farbe():string</text><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacing" textLength="156" x="47" y="210.667">set_farbe(string):void</text><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacing" textLength="73" x="47" y="226.9639">info():void</text></g><!--class Schrank--><g id="elem_Schrank"><rect codeLine="2" fill="#F1F1F1" height="162.0781" id="Schrank" rx="2.5" ry="2.5" style="stroke:#181818;stroke-width:0.5;" width="340" x="7" y="294"/><ellipse cx="143.75" cy="310" fill="#ADD1B2" rx="11" ry="11" style="stroke:#181818;stroke-width:1.0;"/><path d="M146.0938,305.6719 C145.1563,305.2344 144.5625,305.0938 143.6875,305.0938 C141.0625,305.0938 139.0625,307.1719 139.0625,309.8906 L139.0625,311.0156 C139.0625,313.5938 141.1719,315.4844 144.0625,315.4844 C145.2813,315.4844 146.4375,315.1875 147.1875,314.6406 C147.7656,314.2344 148.0938,313.7813 148.0938,313.3906 C148.0938,312.9375 147.7031,312.5469 147.2344,312.5469 C147.0156,312.5469 146.8125,312.625 146.625,312.8125 C146.1719,313.2969 146.1719,313.2969 145.9844,313.3906 C145.5625,313.6563 144.875,313.7813 144.1094,313.7813 C142.0625,313.7813 140.7656,312.6875 140.7656,310.9844 L140.7656,309.8906 C140.7656,308.1094 142.0156,306.7969 143.75,306.7969 C144.3281,306.7969 144.9375,306.9531 145.4063,307.2031 C145.8906,307.4844 146.0625,307.7031 146.1563,308.1094 C146.2188,308.5156 146.25,308.6406 146.3906,308.7656 C146.5313,308.9063 146.7656,309.0156 146.9844,309.0156 C147.25,309.0156 147.5156,308.875 147.6875,308.6563 C147.7969,308.5 147.8281,308.3125 147.8281,307.8906 L147.8281,306.4688 C147.8281,306.0313 147.8125,305.9063 147.7188,305.75 C147.5625,305.4844 147.2813,305.3438 146.9844,305.3438 C146.6875,305.3438 146.4844,305.4375 146.2656,305.75 L146.0938,305.6719 Z " fill="#000000"/><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacing" textLength="58" x="164.25" y="314.8467">Schrank</text><line style="stroke:#181818;stroke-width:0.5;" x1="8" x2="346" y1="326" y2="326"/><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacing" textLength="89" x="13" y="342.9951">spiegel:bool</text><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacing" textLength="89" x="13" y="359.292">n_tueren:int</text><line style="stroke:#181818;stroke-width:0.5;" x1="8" x2="346" y1="366.5938" y2="366.5938"/><text fill="#000000" font-family="sans-serif" font-size="14" font-style="italic" lengthAdjust="spacing" textLength="82" x="13" y="383.5889">Konstruktor</text><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacing" textLength="246" x="95" y="383.5889">(float, float, float, string, bool, int)</text><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacing" textLength="131" x="13" y="399.8857">get_spiegel():bool</text><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacing" textLength="131" x="13" y="416.1826">get_n_tueren():int</text><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacing" textLength="73" x="13" y="432.4795">info():void</text><text fill="#000000" font-family="sans-serif" font-size="14" font-style="italic" lengthAdjust="spacing" textLength="93" x="13" y="448.7764">"+"-Operator</text><text fill="#000000" font-family="sans-serif" font-size="14" lengthAdjust="spacing" textLength="131" x="106" y="448.7764">(Schrank):Schrank</text></g><!--reverse link Moebel to Schrank--><g id="link_Moebel_Schrank"><path codeLine="4" d="M177,254.447 C177,267.862 177,281.176 177,293.78 " fill="none" id="Moebel-backto-Schrank" style="stroke:#181818;stroke-width:1.0;"/><polygon fill="none" points="170,254.089,177,234.089,184,254.088,170,254.089" style="stroke:#181818;stroke-width:1.0;"/></g><!--SRC=[bP1B3eCW54Ndhe8uqbJZd7G7JTD15s3GFfL8U0rYHrryGMZ1pwGZu9myxeLMi6aYLuG6HD8kXtixA2R7977q_2xBm3mab0W6iWVQ2MGwq05XsC560TSxsZ7L09squh8FjAekA0sSHusggh9bg23hnGtbOQe7NRj2MRxDiMwfTQnSkMEtL3HgMtBwET-4lf0_WkUomyp3nF-T7Njow47G1b54MDPw1WMISgaZ_CTF5CHUMPXSdKSts2VuJDDcashbDzdOTNRyWBXHUahBsnCKSvMyogdVV000]--></g></svg>
\ No newline at end of file
diff --git a/Semester_2/Einheit_11/Uebung_Python_to_Cpp.ipynb b/Semester_2/Einheit_11/Uebung_Python_to_Cpp.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..dd88346e9532316bf25b289170b5ce0efc7312a9
--- /dev/null
+++ b/Semester_2/Einheit_11/Uebung_Python_to_Cpp.ipynb
@@ -0,0 +1,201 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "18a8ddd0",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'> Ãœbung 8: C++ </font>\n",
+ "\n",
+ "#### <font color='blue'> Problemstellung: Ãœbersetzung einer Python Klassenstruktur nach C++ </font>\n",
+ "\n",
+ "Folgende Klassenstruktur und Hauptfunktion soll nach C++ nachprogrammiert werden.\n",
+ "\n",
+ "Die Klasse `Moebel` hat die Attribute `laenge`, `hoehe`, `breite` und `farbe`, die über den Konstruktor gesetzt werden. Alle diese Attribute haben eine `get`-Methode, `farbe` hat zudem eine `set`-Methode (Hintergrund: Die Farbe kann bei einem Möbelstück leicht geändert werden, für die Maße wäre ein erheblicher Umbau erforderlich). Außerdem hat die Klasse eine Methode `info`, die eine Textausgabe erzeugt und die Daten über das Möbelstück auf dem Bildschirm ausgibt. Zum Beispiel im Format: \"Das Möbelstück ist 100 cm lang, 80 cm hoch, 40 cm breit und hat die Farbe schwarz.\"\n",
+ "\n",
+ "Davon abgeleitet ist die Klasse `Schrank`. Diese hat zusätzlich ein Attribut `spiegel`, das über einen Wahrheitswert enthält, ob ein Spiegel vorhanden ist. Außerdem hat es `n_tueren`, das die Anzahl der Türen speichert. Beide haben eine get, aber keine set-Methode. Die `info`-Methode ist entsprechend erweitert, um auch die Informationen über die beiden zusätzlichen Attribute zu enthalten.\n",
+ "\n",
+ "Der Additionsoperator wird für Schränke definiert und dabei als nebeneinanderstellen interpretiert. Dabei wird die Länge addiert und bei Höhe und Breite der höhere Wert genommen. Wenn die Farbe gleich ist, wird diese Farbe übernommen, ansonsten \"mehrfarbig\". Die Anzahl der Türen wird addiert und, ob der neue Schrank einen Spiegel hat, ist davon abhängig, ob einer der beiden Schränke einen Spiegel hat.\n",
+ "\n",
+ "In der Hauptfunktion wird diese Funktionalität getestet.\n",
+ "\n",
+ "Die Klassenstruktur ist im folgenden UML-Diagramm gezeigt:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "aa979a2f",
+ "metadata": {},
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8dfa507a",
+ "metadata": {},
+ "source": [
+ "Moebel:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "6278b740",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "class Moebel:\n",
+ " def __init__(self, laenge, hoehe, breite, farbe):\n",
+ " self.laenge = laenge\n",
+ " self.hoehe = hoehe\n",
+ " self.breite = breite\n",
+ " self.farbe = farbe\n",
+ " \n",
+ " def get_laenge(self):\n",
+ " return self.laenge\n",
+ " \n",
+ " def get_hoehe(self):\n",
+ " return self.hoehe\n",
+ " \n",
+ " def get_breite(self):\n",
+ " return self.breite\n",
+ " \n",
+ " def get_farbe(self):\n",
+ " return self.farbe\n",
+ " \n",
+ " def set_farbe(self,farbe):\n",
+ " self.farbe = farbe\n",
+ " \n",
+ " def info(self):\n",
+ " print(f'Das Möbelstück ist {self.laenge} cm lang, {self.hoehe} cm hoch, {self.breite} cm breit und hat die Farbe {self.farbe}.')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "49ce2521",
+ "metadata": {},
+ "source": [
+ "Schrank:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "8b33d53b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "class Schrank(Moebel):\n",
+ " def __init__(self, laenge, hoehe, breite, farbe, spiegel, n_tueren):\n",
+ " super().__init__(laenge, hoehe, breite, farbe)\n",
+ " self.spiegel = spiegel\n",
+ " self.n_tueren = n_tueren\n",
+ " \n",
+ " def get_spiegel(self):\n",
+ " return self.spiegel\n",
+ " \n",
+ " def get_n_tueren(self):\n",
+ " return self.n_tueren\n",
+ " \n",
+ " def info(self):\n",
+ " if self.spiegel:\n",
+ " print(f'Der Schrank ist {self.laenge} cm lang, {self.hoehe} cm hoch, {self.breite} cm breit, {self.farbe}, hat {self.n_tueren} Türen und Spiegel.')\n",
+ " else:\n",
+ " print(f'Der Schrank ist {self.laenge} cm lang, {self.hoehe} cm hoch, {self.breite} cm breit, {self.farbe}, hat {self.n_tueren} Türen und keine Spiegel.')\n",
+ " \n",
+ " def __add__(self, s2):\n",
+ " \n",
+ " # Variablen, die eine if Struktur erfordern: \n",
+ " h = self.hoehe\n",
+ " b = self.breite\n",
+ " f = self.farbe\n",
+ " \n",
+ " if self.hoehe < s2.hoehe:\n",
+ " h = s2.hoehe\n",
+ " \n",
+ " if self.breite > s2.breite:\n",
+ " b = s2.breite\n",
+ " \n",
+ " if self.farbe != s2.farbe:\n",
+ " f = \"mehrfarbig\"\n",
+ " \n",
+ " # Restliche variablen direkt in-place berechnet\n",
+ " return Schrank(self.laenge + s2.laenge, h, b, f, self.spiegel or s2.spiegel, self.n_tueren + s2.n_tueren)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5e1e35bf",
+ "metadata": {},
+ "source": [
+ "Testfunktion:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "ebb28f33",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Test: Klasse Moebel: \n",
+ "Das Möbelstück ist 100 cm lang, 80 cm hoch, 40 cm breit und hat die Farbe blau.\n",
+ "Hoehe von m1: 80 cm.\n",
+ "Das Möbelstück ist 100 cm lang, 80 cm hoch, 40 cm breit und hat die Farbe schwarz.\n",
+ "\n",
+ "\n",
+ "Test: Klasse Schrank:\n",
+ "Der Schrank ist 100 cm lang, 180 cm hoch, 60 cm breit, weiss, hat 2 Türen und Spiegel.\n",
+ "Der Schrank ist 60 cm lang, 200 cm hoch, 60 cm breit, weiss, hat 1 Türen und keine Spiegel.\n",
+ "Der Schrank ist 160 cm lang, 200 cm hoch, 60 cm breit, weiss, hat 3 Türen und Spiegel.\n",
+ "Der Schrank ist 160 cm lang, 200 cm hoch, 60 cm breit, mehrfarbig, hat 3 Türen und Spiegel.\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Test: Klasse Moebel: \")\n",
+ "\n",
+ "m1 = Moebel(100, 80, 40, \"blau\")\n",
+ "m1.info()\n",
+ "print(f\"Hoehe von m1: {m1.get_hoehe()} cm.\")\n",
+ "\n",
+ "m1.set_farbe(\"schwarz\")\n",
+ "m1.info()\n",
+ "\n",
+ "print(\"\\n\\nTest: Klasse Schrank:\")\n",
+ "s1 = Schrank(100, 180, 60, \"weiss\", True, 2)\n",
+ "s1.info()\n",
+ "s2 = Schrank(60, 200, 60, \"weiss\", False, 1)\n",
+ "s2.info()\n",
+ "(s1+s2).info()\n",
+ "s2.set_farbe(\"schwarz\")\n",
+ "(s1+s2).info()"
+ ]
+ }
+ ],
+ "metadata": {
+ "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
+}