C++ praxisnah lernen (mit spannenden Projekten)

In diesem Abschnitt lernst du das erste Projekt kennen, das du in diesem Kurs umsetzen wirst. Du wirst ein Programm schreiben, mit dem du geheime Nachrichten verschlüsseln und wieder entschlüsseln kannst.

Hier lernst du, wie du ein Grundgerüst für deine Programme aufbaust. Dazu gehören die Definition der main()-Funktion, die Einbindung von Bibliotheken und die Verwendung von Namensräumen.

In diesem Abschnitt lernst du, wie mit Hilfe von Variablen Informationen gespeichert und durch Operatoren verarbeitet werden können. Außerdem lernst du einige erste Datentypen kennen, mit denen du z.B. Zahlen, Zeichen oder Texte im Speicher deines Computers ablegen kannst.

Hier lernst du, wie du den Programmfluss von bestimmten Bedingungen abhängig machen kannst. Dies können z.B. Benutzereingaben sein, die du über die Tastatur einliest oder auch Daten, die du aus einer Datei oder einem Sensor gelesen werden. Je nach dem, welche Daten du erhältst, kann dein Programm dann einen unterschiedlichen Ausführungspfad nehmen - der Programmfluss wird verzweigt.

Hier lernst du, wie du mit Hilfe der while-Schleife Anweisungen wiederholen kannst. Dies ist z.B. dann nützlich, wenn du eine bestimmte Anzahl von Wiederholungen benötigst oder wenn du etwas so lange ausführen möchtest, bis eine bestimmte Bedingung erfüllt ist.

Hier sehen wir uns den Programmablauf des ersten Projekts an. Wir werden uns dabei auf den ersten Teil konzentrieren, in dem der Benutzer auswählen kann, ob er einen Text ver- oder entschlüsseln möchte. Der Code für diesen Teil des Projekts ist relativ kurz und übersichtlich, so dass du ihn gut verstehen und nachvollziehen kannst. Die übrigen Teile werden wir dann in den nächsten Kapiteln besprechen.

In diesem Abschnitt sehen wir uns an, wie wir den Benutzer fragen können, ob er ver- oder entschlüsseln möchte, um dann entsprechend zu reagieren. Dazu verwenden wir eine if-Anweisung, mit der wir die Eingabe des Benutzers prüfen und bei Wahl der Verschlüsselung einen entsprechenden Text ausgeben.

Nachdem wir im letzten Abschnitt gesehen haben, wie wir mit if auf die Eingabe des Benutzers reagieren können, wollen wir jetzt noch den Fall betrachten, dass der Benutzer den Entschlüsselungs-Modus wählt. Außerdem wollen wir noch ungültige Eingaben abfangen, damit immer klar ist, wie reagiert werden soll.

In diesem Abschnitt sehen wir uns in einem Ablaufdiagramm an, wie wir den zu verschlüsselnden Text zeichenweise verarbeiten und in Zahlencodes umwandeln können. Dazu verwenden wir eine while-Schleife, die so lange wiederholt wird, bis das Ende des Textes erreicht ist. Dieser zweite Teil des Projekts ist die Vorstufe zur eigentlichen Verschlüsselung, die wir dann im dritten Teil und letzten Teil umsetzen werden.

In diesem Abschnitt sehen wir uns an, wie wir mit Hilfe einer while-Schleife zeichenweise auf einen Text zugreifen können. Im Schleifenkörper werden wir dann die einzelnen Zeichen zusammen mit dem Schleifenindex untereinander ausgeben, bevor wir im nächsten Abschnitt die Zeichen in ASCII-Codes umwandeln, der Basis für die Verschlüsselung in diesem Projekt.

Hier sehen wir uns an, wie wir mit Hilfe von ASCII-Codes einen Text in Zahlen konvertieren können. Dazu verwenden wir ein Konzept namens Casting, mit dem wir den Datentyp einer Variablen ändern können. Das Programm wird nach diesem Abschnitt die einzelnen Zeichen des eingegebenen Textes untereinander ausgeben und dabei den ASCII-Code des jeweiligen Zeichens anzeigen.

In diesem Abschnitt werden wir uns mit der Cäsar-Verschlüsselung beschäftigen, die auf den römischen Feldherrn Julius Cäsar zurückgeht. Dieser hat diese Methode verwendet, um geheime Botschaften an seine Generäle zu übermitteln. Dieses sehr einfache Verfahren ist zwar leicht zu knacken, aber dennoch ein guter Einstieg in die Welt der Verschlüsselung und tolle Programmierübung.

Hier beschäftigen wir uns mit der zyklischen Verschiebung von Zahlen für die Cäsar-Verschlüsselung. Dazu werden wir den Modulo-Operator verwenden, der den Rest einer Division zurückgibt. Damit können wir Zahlen auf einen eingeschränkten Bereich abbilden, ohne dass der Wertebereich überschritten wird.

In diesem Abschnitt werden wir endlich die eigentliche Verschlüsselung in unseren Projekt-Code einfügen. Dazu werden wir die Cäsar-Verschlüsselung mit der Modulo-Operation kombinieren, um eine zyklische Verschiebung zu erreichen, damit auch alle Zeichen des Alphabets verschlüsselt werden können und zwar weitgehend unabhängig von der gewählten Geheimzahl.

In diesem Abschnitt lernst du das zweite Projekt kennen, das du in diesem Kurs umsetzen wirst. Du wirst einen Movie-Player entwickeln, mit dem du auf der Kommandozeile Filme abspielen kannst, die aus sich verändernden Textzeichen (d.h. ASCII-Codes) bestehen und so den Eindruck von Bewegung erzeugen.

In diesem Abschnitt lernst du die for-Schleife kennen, mit der du Anweisungen wiederholen kannst. Du wirst sehen, dass sich diese Schleifenart besonders gut eignet, wenn die Anzahl der Durchläufe bereits zu Beginn bekannt ist, z.B. wenn du die Elemente einer Liste nacheinander verarbeiten möchtest.

In diesem Abschnitt lernst du, wie du mit der fstream-Bibliothek Dateien lesen und schreiben kannst. Du wirst sehen, dass die Anwendung sehr ähnlich zur üblichen Ein- und Ausgabe mit cin und cout ist. Das ist sehr praktisch, weil du so auf sehr einfache Weise mit Dateien und deren Inhalt arbeiten kannst.

In diesem Abschnitt lernst du, wie du mit Arrays gleichartige Daten unter einem Namen zusammenfassen kannst. Du wirst sehen, dass Arrays sehr praktisch sind, wenn du z.B. eine ganze Reihe von Werten verwalten möchtest, die alle den gleichen Datentyp und ähnliche Informationen haben.

In diesem Abschnitt lernst du, wie du mit mehrdimensionalen Arrays Daten in einer tabellarischen Form organisieren kannst. Du wirst sehen, dass sich mit dieser Datenstruktur sehr leicht komplexere Datenstrukturen wie Tabellen oder Bilder verwalten lassen und dass sich die Anwendung von mehrdimensionalen Arrays kaum von der von eindimensionalen Arrays unterscheidet.

In diesem Abschnitt lernst du, wie du mit Vektoren flexible Arrays erzeugen kannst, die sich zur Laufzeit vergrößern und verkleinern lassen. Außerdem bieten Vektoren einige nützliche Zusatzfunktionen, wie z.B. die Ermittlung der Anzahl der in ihnen gespeicherten Elemente, die dir das Leben leichter machen.

Vektoren sind eine flexible Alternative zu klassischen Arrays, die mit einer Reihe von Zusatzfunktionen ausgestattet sind. In diesem Abschnitt lernst du, wie du Elemente in Vektoren einfügen, löschen und sogar der Größe nach sortieren kannst.

In diesem Abschnitt wird das Ablaufdiagramm zum ersten Teil des zweiten Projekts vorgestellt. Es zeigt, wie die Filmdaten aus einer Datei eingelesen und im Speicher abgelegt werden. Dabei spielen Schreibzugriffe, Verzweigungen und Schleifen eine wichtige Rolle.

In diesem Abschnitt geht es darum, die Filmdatei zum Lesen zu öffnen und für den Fall, dass dies nicht funktioniert, eine Fehlermeldung auszugeben und das Programm zu beenden. Das Einlesen der Daten in eine geeignete Datenstruktur im Speicher wird im nächsten Abschnitt behandelt.

In diesem Abschnitt geht es darum, die Datenstrukturen zu erzeugen, mit der die Filmdaten und andere Informationen in geeigneter Form im Speicher abgelegt werden sollen. Dazu werden wir uns zunächst die Struktur der Filmdatei ansehen und dann die passenden Datenstrukturen definieren.

In diesem Abschnitt geht es darum, die Filmdaten zeilenweise aus der Datei in den Arbeitsspeicher zu laden und in den Datenstrukturen zu speichern, die wir im letzten Abschnitt definiert haben.

In diesem Abschnitt geht es darum, einige Statistiken zum eingelesenen Film zu ermitteln und in der Kommandozeile auszugeben. Dazu werden wir uns zunächst ein Ablaufdiagramm ansehen, bevor wir dann im nächsten Abschnitt den Code hierfür schreiben. Um später den Anschein einer Animation zu erwecken, benötigen wir z.B. die Höhe des Films in Bildzeilen, um das Terminal-Fenster entsprechend anzupassen.

Nachdem wir uns im letzten Abschnitt den Ablaufplan für den zweiten Teil des Projekts angesehen haben, wollen wir uns nun darum kümmern, die darin gezeigten Film-Statistiken zu berechnen und auszugeben. Zum einen ist es eine gute Übung, um den Umgang mit Vektoren zu vertiefen, zum anderen benötigen wir einige dieser Informationen später noch, z.B. um die Höhe des Terminal-Fensters anzupassen.

In diesem Abschnitt geht es darum, die eingelesenen Bilder so auszugeben, dass der Eindruck einer Animation entsteht. Dazu werden wir uns zunächst ein Ablaufdiagramm ansehen, bevor wir dann, wie in den vorherigen Teilen auch schon, im nächsten Abschnitt den Code hierfür schreiben.

In diesem Abschnitt geht es darum, den Nutzer dabei zu unterstützen, die Höhe des Terminal-Fensters so anzupassen, dass die Anzahl der sichtbaren Zeilen genau der Anzahl der Zeilen im Film entspricht. Ist dies der Fall, dann entsteht der Eindruck einer flüssigen Animation, die sich von oben nach unten durch das Terminal-Fenster bewegt. Aus diesem Grund benötigen wir unter anderem die Anzahl der Zeilen pro Bild, die wir im zweiten Teil des Projekts über eine Maximumsuche ermittelt haben.

Nachdem wir im letzten Abschnitt die Anpassung der Terminal-Größe besprochen haben, können wir uns nun endlich mit dem Abspielen der Film-Bilder beschäftigen. Die Idee dabei ist, die einzelnen Bilder zeilenweise in der Kommandozeile auszugeben, wobei die Ausgabe in einem Tempo erfolgen soll, dass der Eindruck einer flüssigen Animation entsteht.

In diesem Abschnitt geht es darum, die Grundidee des Spieleklassikers Angry Birds aufzugreifen und in ein Programm für die Kommandozeile umzusetzen - inklusive einer einfachen, textbasierten Grafik. Dabei werden wir dein bisheriges Wissen weiter vertiefen und neue Konzepte wie Zeiger und Referenzen kennenlernen. Am Ende dieses Kapitels wirst du ein komplexes Programm geschrieben haben, das du mit einigen Erweiterungen sogar noch weiter ausbauen kannst.

In diesem Kapitel lernst Du, wie Du mit Structs eigene Datentypen definieren und verwenden kannst. Structs sind eine Erweiterung der elementaren Datentypen, die es Dir ermöglichen, mehrere Variablen in einer Einheit zusammenzufassen. Dadurch kannst Du komplexe Datenstrukturen erstellen, die sich leichter verwalten lassen als eine Ansammlung von elementaren Datentypen.

In diesem Abschnitt lernst Du, wie Du Structs ineinander verschachteln kannst, um komplexere Datenstrukturen zu erstellen. Structs können beliebig verschachtelt werden, d.h. ein Struct kann ein anderes Struct enthalten, das wiederum ein anderes Struct enthält. Dadurch können logisch gruppierte Datenstrukturen erstellt werden, die leichter zu verwalten sind als eine Ansammlung von elementaren Datentypen.

In diesem Abschnitt lernst Du, wie Du Structs in dynamischen Datenstrukturen wie Vektoren speichern und organisieren kannst. Dadurch lassen sich größere Datensätze, z.B. zu den Teilnehmenden eines Programmierkurses, sehr leicht verwalten, da wir die Vorteile von Vektoren und Structs kombinieren können.

In diesem ersten Abschnitt lernst du, wie Funktionen grundsätzlich aufgebaut sind. Wir sehen uns ein erstes, einfaches Beispiel an, an dem du sehen kannst, wie du Code aus main() auslagern kannst. 

Im letzten Abschnitt hast du gelernt, was Funktionen sind und wie sie aufgebaut sind. Hier geht es darum, wie du Daten an Funktionen übergeben kannst, damit diese im Funktionskörper verarbeitet werden.

In diesem Abschnitt lernst du, wie du Daten aus Funktionen an die aufrufende Seite zurückgeben kannst. Dazu ersetzen wir das Schlüsselwort void() durch einen Datentyp und nutzen das Schlüsselwort return, um z.B. Ergebnisse von Berechnungen aus der Funktion heraus zu transportieren.

In diesem Abschnitt lernst du die do-while-Schleife als Alternative zur bereits bekannten while-Schleife kennen. Diese Art von Schleife ist besonders nützlich, wenn du sicherstellen möchtest, dass der Schleifenkörper mindestens einmal ausgeführt wird, bevor die Bedingung überprüft wird.

In diesem Abschnitt lernst du, was Referenzen sind und wie du sie in C++ verwenden kannst, um zu vermeiden, dass unnötige Kopien von Daten erstellt werden. Dadurch kannst du die Performance deiner Programme verbessern und Speicherplatz sparen. Außerdem lernst du, wie du Referenzen in Funktionen einsetzen kannst, um direkt auf die Originaldaten zuzugreifen und diese zu verändern.

In diesem Abschnitt lernst du, was Zeiger sind und wie du mit Ihnen den Speicher deines Programms manipulieren kannst. Zeiger erlauben es dir, Speicheradressen abzulegen und auf die dahinter liegenden Daten zuzugreifen. Außerdem ist es damit leicht möglich, einen Datenaustausch zwischen verschiedenen Programmteilen (z.B. Funktionen) zu realisieren, ohne die Daten jedes Mal kopieren zu müssen.

In diesem Abschnitt befassen wir uns mit dem Lese- und Schreibzugriff auf Speicherinhalte, die wir über einen Zeiger ansprechen. Wir werden sehen, wie wir mit dem Dereferenzierungsoperator * auf den Speicherinhalt hinter einem Zeiger zugreifen können, um diesen auszulesen oder zu überschreiben.

In diesem Abschnitt lernst du, wie du Zeiger in einer Liste speichern kannst. Das ist z.B. dann sinnvoll, wenn du eine Sammlung von Objekten verwalten möchtest, die du später in einer Schleife durchlaufen und bearbeiten möchtest, ohne dabei unabsichtlich Kopien der Objekte zu erzeugen.

Im dritten Projekt entwickeln wir das Spiel Wütende Vögel, das an den Klassiker Angry Birds angelehnt ist. Ziel ist es, mit einer Schleuder Vögel auf Schweine zu schießen. Der Spieler kann die Schleuder in einem bestimmten Winkel ausrichten und die Abschussgeschwindigkeit festlegen. In diesem Abschnitt sehen wir uns das Ablaufdiagramm zum ersten Teil, in dem das Grundgerüst und das Spielfeld entstehen.

Hinweis: Die lauffähige Version zum ersten Teil findest du im Abschnitt "Eine erste Variante der main()-Funktion"

In diesem Abschnitt werden wir die Datenstruktur GameArea definieren, die das Spielfeld repräsentiert. Sie ist das zentrale Element in unserem Spiel und enthält sämtliche Elemente, die für die Darstellung und das Management des Spielfelds notwendig sind. Die Struktur wird später verwendet, um eine Instanz des Spielfelds zu erstellen, die wir dann mit Leben füllen können.

In diesem Abschnitt werden wir die Funktion initGameArea() betrachten, die das Spielfeld initialisiert. Hierin werden die Dimensionen des Spielfelds festgelegt und die Bodenebene sowie die Schleuder positioniert. Anschließend wird das Spielfeld mit Leerzeichen gefüllt sowie Bodenebene und Schleuder symbolhaft eingezeichnet. In späteren Teilen des Projekts wird die Funktion noch um die Positionierung der Vögel und Schweine erweitert, diese sind jedoch für den Anfang noch nicht nötig.

In diesem Abschnitt werden wir die Funktion printGameArea() betrachten, die das Spielfeld auf der Kommandozeile ausgibt. Die Funktion wird im Verlauf des Programms an mehreren Stellen aufgerufen, um das Spielfeld zu aktualisieren, z.B. nachdem ein Vogel abgefeuert wurde oder ein Schwein getroffen wurde.

In diesem Abschnitt werden wir eine erste Variante der main()-Funktion betrachten. In der ersten Ausbaustufe des Spiels wird hierin zuerst das Spielfeld initialisiert und anschließend im Terminal ausgegeben.

In diesem Teil findest du die erste lauffähige Version des Spiels, mit der das Spielfeld (Bodenebene und Schleuder) angezeigt werden kann.

In diesem Abschnitt werden wir das Ablaufdiagramm zum Einfügen von Vögeln und Schweinen in die Spielwelt betrachten. Wir erweitern dazu das Ablaufdiagramm aus dem letzten Abschnitt um das Hinzufügen von Vögeln und Schweinen in die Spielwelt, wobei Änderungen grün markiert sind.

In diesem kurzen Abschnitt werden wir uns mit den Datenstrukturen befassen, die wir für die Vögel und Schweine benötigen. Diese müssen z.B. die Position der Objekte in der Spielwelt beschreiben, damit wir sie später zeichnen können. Außerdem müssen wir festhalten, ob ein Objekt bereits verwendet wurde oder nicht, damit wir Schweine nicht mehrfach treffen oder Vögel wiederholt abfeuern können.

In diesem Abschnitt werden wir die Funktionen initGameArea() und printGameArea() so anpassen, dass sie mit Call-by-Reference arbeiten. Dadurch können wir aus der main()-Funktion die Originaldaten direkt an die Funktionen übergeben und darin verändern, ohne dass wir die Ergebnisse umständlich mit return zurückgeben müssen. Dadurch werden zwei unnötige Kopien eingespart.

In diesem Abschnitt befassen wir uns mit dem Einzeichnen von Objekten in die Spielwelt. Dazu zählen das Runden der Objekt-Koordinaten auf ganzzahlige Werte, die Überprüfung, ob die Koordinaten innerhalb der Spielwelt liegen, und das Einzeichnen des Objekt-Symbols in den zweidimensionalen Spielwelt-Vektor.

In diesem Abschnitt werden wir zwei Funktionen schreiben, um die Vögel und Schweine in die Spielwelt einzufügen. Dazu wird zuerst ein neues Vogel- bzw. Schweineobjekt erzeugt, mit Hilfe der Funktion drawObject() in die Spielwelt eingefügt und anschließend in die Liste der Vögel bzw. Schweine eingefügt.

In diesem Abschnitt werden wir die Funktionen addBird() und addPig() in die main()-Funktion einfügen, um Vögel und Schweine an festgelegten Positionen in die Spielwelt einzufügen. In der Terminal-Ausgabe sind diese dann als o bzw. @ links und rechts neben der Schleuder zu sehen.

In diesem Abschnitt werden wir das Ablaufdiagramm zum Einlegen von Vögeln in die Schleuder betrachten. Das Einlegen erfolgt in einer Schleife, die nacheinander alle verfügbaren Vögel abarbeitet. Für jeden Vogel werden der Winkel und die Abschussgeschwindigkeit vom Nutzer abgefragt und - im Anschuss an die in diesem Teil noch fehlende Flugbahn-Berechnung - der Vogel abgeschossen. Sobald alle Vögel verwendet wurden, wird die Schleife beendet und das Spiel ist zu Ende.

In diesem Abschnitt werden wir die Funktion getNextBird() implementieren, die den nächsten Vogel in die Schleuder legt. Dazu werden wir die Funktion drawObject() erweitern, die wir bereits im letzten Teil kennengelernt haben. Au\ss{}erdem werden wir die Funktion getNextBird() implementieren, die den nächsten Vogel von seiner Warteposition löscht und auf Höhe der Schleuder neu einzeichnet.

In diesem Abschnitt werden wir die Spielschleife und die Nutzerinteraktion in der main()-Funktion implementieren. Dazu werden wir die Funktion getNextBird() aus dem letzten Abschnitt nutzen, um die Vögel nacheinander in die Schleuder zu legen. Au\ss{}erdem werden wir dem Nutzer die Möglichkeit geben, den Abschusswinkel und die Abschussgeschwindigkeit einzugeben, die wir dann später für die Flugbahnberechnung nutzen werden.

In diesem Abschnitt werden wir das Ablaufdiagramm zum vierten Teil des Spiels Wütende Vögel erstellen. Dieses Ablaufdiagramm enthält bereits alle wesentlichen Funktionen des Spiels, so dass wir am Ende dieses Kapitels eine lauffähige Version haben werden. Neu hinzu kommen die Flugbahnberechnung der abgeschossenen Vögel sowie die Prüfung von Kollisionen mit den Schweinen.

In diesem Abschnitt werden wir ein einfaches physikalisches Modell zur Berechnung der Flugbahn der abgeschossenen Vögel implementieren. Dazu werden wir die Funktion updateBird() implementieren, die in jedem Simulationsschritt die Position des Vogels aktualisiert.

In diesem Abschnitt werden wir die Funktion checkCollision() implementieren, mit der wir prüfen können, ob ein Vogel ein Schwein getroffen hat. Dazu werden wir die Distanz zwischen dem Mittelpunkt des Vogels und dem Mittelpunkt des Schweins berechnen und mit einem Schwellwert vergleichen. Ist die Distanz kleiner als der Schwellwert, so wird angenommen, dass der Vogel das Schwein getroffen hat.

In diesem Abschnitt werden wir die main()-Funktion um die Flugbahnberechnung und die Kollisionsprüfung erweitern. Außerdem implementieren wir eine Schleife, mit der wir die Simulation des Vogelflugs in kleinen Zeitschritten durchführen können.

Herzlichen Glückwunsch, du hast es geschafft! Du hast in den drei Projekten aus diesem Kurs schon eine Menge gelernt und du bist nun in der Lage, auch umfangreichere Programme nachzuvollziehen und zu erweitern. In diesem Abschnitt bekommst du einen Ausblick auf weitere Themen, die du dir anschauen könntest, um deine Kenntnisse zu vertiefen.