C++ für Kids - mitp · In diesem Buch hast du es mit der Programmiersprache C++ zu tun. Sie ist seit vie-len Jahren sehr weit verbreit et, allerdings nicht leicht zu erlernen. Dafür

5

Inhalt

Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11Welches Werkzeug benötigen wir? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12Und was bietet dieses Buch? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13Wie arbeite ich mit diesem Buch? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13Was brauchst du für dieses Buch? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14Hinweise für Lehrer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

1Erste Schritte mit C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17Visual Studio starten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18Kleine Spritztour durchs Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19Das erste Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20Der Quelltext . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25Der Aufbau eines Programms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27Hallo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28cout und cin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33Visual Studio beenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37Ein paar Fragen ... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38... und eine Aufgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

2Typen und Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39Variablen und Werte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40Typenvielfalt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43ä-ö-ü-ß . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45Rechenspiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47Operationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50Ausgabe mit Format . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53Mathe mit Strings? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55Konstanten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

© des Titels »C++ für Kids« (ISBN 9783958457126) 2017 by mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/712

Inhalt

6

Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58Ein paar Fragen ... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58... und zwei Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

3 Kontrolle und Auswahl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61Ein Projekt öffnen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62Die if-Struktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65if und else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68Vergleichsoperatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71Verknüpfungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73Von Fall zu Fall . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79Ein paar Fragen ... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80... und ein paar Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

4 Wiederholungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81Zufallszahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82Es darf geraten werden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84while oder do-while? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87Wie oft? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88Zählschleifen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90break oder continue? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92Verschachtelungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98Ein paar Fragen ... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99... und ein paar Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99

5 Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101C++ ist lernfähig . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102Init, Play, Evaluate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105Lokal oder global? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106Parameter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109Wertverlust? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111bool und return . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112Wert oder Referenz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116Prototypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122Ein paar Fragen ... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122... und ein paar Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122


Inhalt

7

6Arrays, Strukturen, Zeiger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123Variablenfelder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124Dimensionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128Die Sache mit struct . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132Adressen ... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136... und Zeiger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145Ein paar Fragen ... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145... und zwei Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145

7Klassen und Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147Spieler-Struktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148Alles unter einem Hut? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150Es geht nicht ohne public . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153Keine Klasse ohne Konstruktor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156Privatsphäre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159Neue Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161Projekt-Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169Keine Fragen ... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169... aber ein paar Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169

8Vererbung und Polymorphie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171Erbschaften . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172Noch mehr Konstruktoren? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175Überladen von Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178Überschreiben von Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180Polymorphie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183Zeiger auf Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186Destruktionen? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189Objekt-Felder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193Ein paar Fragen ... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194... und zwei Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194

9Container und Datenströme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195Dynamische Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196Suchen und Finden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199


Inhalt

8

Verkettete Listen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201Die Sache mit dem Iterator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204Datenverkehr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207Flexible Mengen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213Ein paar Fragen ... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214... und zwei Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214

10 Buntes Allerlei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215Standardparameter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216Statische Elemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218String-Schnipsel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222Die Sache mit char . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225Operatoren überladen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227Funktions-Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230try und catch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236Ein paar Fragen ... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236... aber keine Aufgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236

11 Kleiner Krabbelkurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237SDL oder SFML? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238Dynamisch und statisch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242Ein Grafikfenster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245Insekt als Player . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249Tastensteuerung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253Grenzkontrollen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260Ein paar Fragen ... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261... und eine Aufgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261

12 Wanzenjagd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263Die Sache mit der Maus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264Ohne Mathe geht es nicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266Freilauf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270Klick und Platt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274Zeit und Punkte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279


Inhalt

9

Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286Ein paar Fragen ... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286... und ein paar Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287

13Game und Player . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289Alles auf neu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290Die Game-Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292Die Player-Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296Play the Game . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300Wanzen-Sammlung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308Ein paar Fragen ... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308... und eine Aufgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308

14Dodge oder Hit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309Ein neuer Player . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310Standing, Ducking, Jumping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313Die Ball-Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317Kollisionskontrollen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321Das Hauptprogramm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328Keine Fragen ... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328... aber ein Paar Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328

15Jump & Run . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329Figuren-Auflauf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330Ein neuer Player . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333Testlauf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336Animation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339Szenenwechsel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343Himmel und Boden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346Farbgebung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348Laufen und Springen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352Keine Fragen ... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352... und nur eine Aufgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352


Inhalt

10

16 Gizmo oder was? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353Die Gizmo-Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354Bunte Scheiben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357Auf dem Weg zum Regenbogen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360Hindernislauf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364Allerlei Dinge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367Sprung-Technik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369Leben und Tod . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374Zusammenfassung und Schluss . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377Keine Fragen ... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377... aber eine Aufgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377

A Anhang A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379Visual Studio installieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379SFML herunterladen und vorbereiten . . . . . . . . . . . . . . . . . . . . . . . . . . . 385Einsatz der Buch-Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388

B Anhang B . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389Kleine Checkliste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389Dem Fehler auf der Spur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390

Stichwortverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393


1 1

Einleitung

Um ein Spiel selbst zu erstellen, muss man vom Programmieren anfangs eigentlichnoch gar nichts verstehen. Denn zuallererst braucht man eine Idee und dann einenPlan.

Wovon soll das Spiel handeln? Welche Geschichte soll es erzählen? Personen, Orteund Ereignisse, all das führt zu einem Plan, der umfasst, was zu diesem Spiel gehö-ren soll. Und erst wenn der Plan »steht«, kann die eigentliche Umsetzung in einProgrammprojekt beginnen. Dann allerdings sollte man schon möglichst gut pro-grammieren können.

Und damit bist du bei diesem Buch genau richtig. Hier bekommst du im ersten Teilüber zehn Kapitel solide und umfassende Grundlagen der Programmiersprache C++vermittelt. Und damit du von Anfang an in die Spieleprogrammierung hinein-schnuppern kannst, sind die Beispiele fast alle auf Spiele bezogen.

Im zweiten Teil geht es dann tatsächlich ans Programmieren von drei richtigen Spie-len, dabei lernst du, dein Grundwissen in C++ immer professioneller anzuwenden.


Einleitung

1 2

Welches Werkzeug benötigen wir?Zuerst einmal zu den Vorkenntnissen: Es sind keine nötig. Denn du beginnst jasozusagen bei null. Allerdings solltest du dich mit Windows auskennen, denn zumProgrammieren brauchen wir natürlich ein Betriebssystem, in dem unsere Pro-gramme laufen.

Was du brauchst, ist eine passende Entwicklungsumgebung und schon kann’s los-gehen. Damit ist ein System aus mehreren Komponenten gemeint:

Um ein Programm zu erstellen, musst du erst mal etwas eintippen. Das ist wie beieinem Brief oder einer Geschichte, die man schreibt. Das Textprogramm dafür kannsehr einfach sein, weil es ja nicht auf eine besondere Schrift oder Darstellungankommt. So etwas wird Editor genannt.

Ist das Programm eingetippt, kann es der Computer nicht einfach lesen und aus-führen. Jetzt muss es so übersetzt werden, dass er versteht, was du von ihm willst.Weil er aber eine ganz andere Sprache spricht als du, muss ein Dolmetscher her. Duprogrammierst in einer Sprache, die du verstehst, und der Dolmetscher übersetzt esso, dass es dem Computer verständlich wird. So etwas heißt dann Compiler.

Schließlich müssen Programme überarbeitet, verbessert, wieder getestet und wei-terentwickelt werden. Dazu gibt es noch einige zusätzliche Hilfen. Daraus wirddann ein ganzes System, die Entwicklungsumgebung.

Mit der von Microsoft kostenlos zur Verfügung gestellten Software Visual Studiohast du eine sehr leistungsfähige Entwicklungsumgebung für die neuestenWindows-Versionen. Die benutzen wir hier.

Weil du nicht programmieren kannst, wie dir der Schnabel gewachsen ist, brauchenwir eine Programmiersprache. Die muss so aufgebaut sein, dass möglichst vieleMenschen in möglichst vielen Ländern einheitlich damit umgehen können.

Weil in der ganzen Welt Leute zu finden sind, die wenigstens ein paar Brocken Eng-lisch können, besteht auch fast jede Programmiersprache aus englischen Wörtern.

In diesem Buch hast du es mit der Programmiersprache C++ zu tun. Sie ist seit vie-len Jahren sehr weit verbreitet, allerdings nicht leicht zu erlernen. Dafür ist C++ dievielleicht mächtigste Sprache überhaupt. Viele Spiele und Spiele-Tools sind in C++programmiert. Daneben gibt es noch einige andere Sprachen wie z.B. C, Java undC#, wobei C als die Mutter vieler Sprachen gilt, auch C++ ist von C abgeleitet.


Und was bietet dieses Buch?

1 3

Und was bietet dieses Buch?Vorwiegend geht es um die Programmiersprache C++ und natürlich um Spiele. Dubekommst hier u.a. serviert:

0 das Basiswissen von C++: Variablen, Ein- und Ausgabe, Kontrollstrukturen,Funktionen

0 Profikenntnisse über Arrays, Zeiger, Grafik, objektorientierte Programmierung

0 wie man eigene Game- und Player-Klassen programmiert

0 Profikenntnisse über Sprites, Bewegungssteuerung, Kollisionen

Im Anhang gibt es dann noch zusätzliche Informationen, u.a. über Installationenund den Umgang mit Fehlern.

Wie arbeite ich mit diesem Buch?Um dir den Weg vom ersten Projekt bis zu einem fertigen Game einfacher zumachen, gibt es einige zusätzliche Symbole, die ich dir hier gern erklären möchte:

Arbeitsschritte

> Wenn du dieses Zeichen siehst, heißt das: Es gibt etwas zu tun. Damit kommenwir beim Entwickeln Schritt für Schritt einem neuen Ziel immer näher.

Grundsätzlich lernt man besser, wenn man Quelltexte selber eintippt oder ändert.Aber nicht immer hat man große Lust dazu. Weil es alle Projekte im Buch auch zumDownload gibt, findest du am Ende des einen oder anderen Abschnitts auch denjeweiligen Dateinamen (z.B. A MyGame). Wenn du also das Projekt nicht selbsterstellen willst, kannst du es stattdessen auch aus dem Internet laden – zu findenunter

www.mitp.de/712

Fragen und Aufgaben

Am Ende eines Kapitels gibt es jeweils einige Fragen und Aufgaben. Diese Übungensind nicht immer ganz einfach, aber sie helfen dir, dein Programmierwissen nochmehr zu vertiefen. Lösungen zu den Aufgaben findest du ebenfalls auf der mitp-Homepage. Du kannst sie dir alle im Editor von Windows oder auch in deinem Text-verarbeitungsprogramm anschauen. Oder du lässt sie dir ausdrucken und hast siedann schwarz auf weiß, um sie neben deinen Computer zu legen.


Einleitung

1 4

Notfälle

Wichtige Stellen im Buch

Hintergrundwissen

Was brauchst du für dieses Buch?Du findest Visual Studio als komplette Entwicklungsumgebung zum Download aufdieser Homepage:

https://www.visualstudio.com/de/downloads/

Visual Studio ist in der Community-Version kostenlos, sie reicht komplett aus, ummit C++ auch umfangreiche Programme zu erstellen. Nach dem Download wirdalles mit dem Setup-Programm in ein Verzeichnis deiner Wahl installiert, z.B.C:\PROGRAMME\ Microsoft VISUAL STUDIO.

Für die Programmierung der Spiele benötigst du noch einige Zusatzmodule, diedann in Visual Studio eingebunden werden. Die findest du unter:

https://www.sfml-dev.org/download.php

SFML ist die Abkürzung für »Simple and Fast Multimedia Library« und ist ein Paket,das zahlreiche Klassen und Funktionen speziell für Grafik und Spiele enthält.

Die Beispielprojekte in diesem Buch findest du ebenso wie die Lösungen zu denAufgaben auf der Homepage des Verlages:

http://www.mitp.de/712

Vielleicht hast du irgendetwas falsch gemacht oder etwas vergessen. Oder eswird gerade knifflig. Dann fragst du dich, was du nun tun sollst. Bei diesemSymbol findest du eine Lösungsmöglichkeit. Auch ganz hinten im Anhang Bfindest du ein paar Hinweise zur Pannenhilfe.

Hin und wieder findest du ein solch dickes Ausrufezeichen im Buch. Dann istdas eine Stelle, an der etwas besonders Wichtiges steht.

Wenn du ein solches »Wow« siehst, geht es um ausführlichere Informationenzu einem Thema.


Hinweise für Lehrer

1 5

Betriebssystem

Die meisten Computer arbeiten heute mit dem Betriebssystem Windows. Davonbrauchst du eine der Versionen ab 7. C++ als universelle Sprache funktioniert auchunter anderen Betriebssystemen (wie z.B. Linux oder Mac OS), worauf wir hier abernicht weiter eingehen.

Speichermedien

Auf jeden Fall benötigst du etwas wie einen USB-Stick oder eine SD-Card, auchwenn du deine Programme auf die Festplatte speichern willst. Auf einem externenSpeicher sind deine Arbeiten auf jeden Fall zusätzlich sicher aufgehoben.

Gegebenenfalls bitte deine Eltern oder Lehrer um Hilfe.

Hinweise für LehrerDieses Buch lässt sich selbstverständlich auch für den Informatik-Unterricht ver-wenden. Dort setzt natürlich jeder Lehrer seine eigenen Schwerpunkte. Aber wennes z.B. um eine Programmier-AG oder einen Informatikkurs mit Schwerpunkt Spie-leprogrammierung geht, lässt sich dieses Buch in Ergänzung zu Ihrem Lehrmaterialgut einsetzen. Und mit Visual Studio steht Ihnen und Ihren Schülern ein mächtigesEntwicklungswerkzeug zur Verfügung.

Was die Programmierung angeht, so wird hier mit C++ keine unbedingt einfacheProgrammiersprache benutzt, aber vielleicht die mächtigste überhaupt. ZahlreicheFragen und Aufgaben mit Lösungen helfen, Gelerntes zu festigen und zu vertiefen.

Auf die Dateien zum Buch verzichten?

Vielleicht ist es Ihnen lieber, wenn Ihre Schüler die Projekte alle selbst erstellen.Dann lassen Sie die Download-Dateien einfach (erst einmal) weg.

Alle Projekt-Ordner mit Spielen enthalten nur die Beispiel-Programme, nichtaber die SFML-Dateien – aus Copyright-Gründen. Du musst sie also selbst inden jeweiligen Projekt-Ordner kopieren.


Einleitung

1 6

Übungsmedien

Für den Informatik-Unterricht sollte jeder Schüler ein eigenes externes Speicher-medium haben, um darauf seine Versuche zu sichern. So wird verhindert, dass sichauf der Festplatte des Schulcomputers mit der Zeit allerlei »Datenmüll« ansammelt.Außerdem dient der eigene Datenträger dem Datenschutz: Nur der betreffendeSchüler kann seine Daten manipulieren.

Regelmäßig sichern

Es kann nicht schaden, die Programmdateien, an denen gerade gearbeitet wird,etwa alle zehn Minuten zu speichern. Denn Computer pflegen gern gerade dann»abzustürzen«, wenn man seine Arbeit längere Zeit nicht gespeichert hat.


17

1 Erste Schritte mit C++

Am besten legen wir gleich los mit dem Programmieren. Nach dem Start des Com-puters und dem Auftauchen von Windows können wir uns schon dem ersten C++-Projekt widmen. Es wird natürlich noch kein Computerspiel sein, aber es gibt schoneiniges zum Herumspielen.

In diesem Kapitel lernst du

$ wie man Visual Studio startet

$ wie man ein Projekt erstellt und ausführt

$ wozu #include gut ist

$ was cout und cin bedeuten

$ etwas über int, char und string

$ wie man ein Projekt speichert

$ wie man Visual Studio beendet


Kapitel 1 Erste Schritte mit C++

18

Visual Studio startenBevor wir mit dem Programmieren anfangen können, muss Visual Studio erst ins-talliert werden. Die Installation übernimmt ein Programm namens Setup. Genaueserfährst du im Anhang A. Hier musst du dir von jemandem helfen lassen, wenn dudir die Installation nicht allein zutraust.

Eine Möglichkeit, Visual Studio zu starten, ist diese:

> Öffne den Ordner, in dem du Visual Studio untergebracht hast (z.B. C:\Programme\ Microsoft Visual Studio).

> Dort musst du nun weiter in einige Unterordner mit den Namen Community\Common7\IDE wechseln:

> Hier suchst du unter den zahlreichen Symbolen eines derjenigen heraus, beidenen etwas aussieht wie eine gekippte lila 8, und zwar das mit dem NamenDevEnv.exe.


Kleine Spritztour durchs Studio

19

> Nun kannst du das Programm mit einem Doppelklick auf das Symbol starten:

Kleine Spritztour durchs StudioJe nach Computer kann es eine Weile dauern, bis Visual Studio geladen ist. Was dichschließlich erwartet, könnte ungefähr so aussehen – wobei das aktuelle Bild unteranderem davon abhängt, ob du eine Verbindung zum Internet hast oder nicht:

Ich empfehle dir, eine Verknüpfung auf dem Desktop anzulegen:0 Dazu klickst du mit der rechten Maustaste auf das Symbol für Visual Studio

(DEVENV.EXE). Im Kontextmenü wählst du KOPIEREN.

0 Dann klicke auf eine freie Stelle auf dem Desktop, ebenfalls mit der rechtenMaustaste. Im Kontextmenü wählst du VERKNÜPFUNG EINFÜGEN.

0 Es ist sinnvoll, für das neue Symbol auf dem Desktop den Text DEVENV.EXE –VERKNÜPFUNG durch VISUAL STUDIO zu ersetzen.

Von nun an kannst du auf das neue Symbol doppelklicken und damit VisualStudio starten.



20

Für den ersten Augenblick ist das vielleicht ein bisschen verwirrend. Da tummeltsich ja einiges auf dem Bildschirm.

Ganz oben kann man die Menüleiste erkennen. Links darunter befinden sich jedeMenge Symbole, die man mit der Maus anklicken kann.

Diese Menüs von Visual Studio wirst du wahrscheinlich am meisten benutzen:

0 Über das DATEI-Menü kannst du Dateien speichern, laden (öffnen), ausdrucken,neu erstellen oder Visual Studio beenden.

0 Das BEARBEITEN-Menü hilft dir bei der Bearbeitung deines Programmtextes, aberauch bei anderen Programmelementen. Außerdem kannst du dort bestimmteArbeitsschritte rückgängig machen oder wiederherstellen.

0 Im ANSICHT-Menü hast du unter anderem die Möglichkeit, zusätzliche Hilfsfens-ter und Boxen ein- oder auszublenden.

0 Über das DEBUGGEN-Menü sorgst du dafür, dass dein Programmprojekt ausge-führt wird.

0 Und das HILFE-Menü bietet dir vielfältige Hilfe-Informationen an.

Ein Editorfenster, wie du es vielleicht von einem Editor oder Textverarbeitungspro-gramm her kennst, ist gerade nicht in Sicht. Was tun? Unser Ziel ist es, ein neuesProjekt – unser Erstlingswerk – zu erstellen. Also los!

Das erste Programm> Klicke in der Menüleiste auf DATEI und im sich öffnenden Menü auf NEU und dann

auf PROJEKT.

Einige wichtige Menüeinträge sind in einem sogenannten Popup-Menüzusammengefasst. Das heißt so, weil es dort aufklappt, wo du gerade mit derrechten Maustaste hinklickst.


Das erste Programm

21

> Oder du suchst im Fenster von Visual Studio weiter unten den Eintrag NEUES

PROJEKT ERSTELLEN und klickst darauf.

Es erscheint ein Dialogfeld, in dem es offenbar mehrere Möglichkeiten gibt, wie dudein Projekt erstellst:



22

> Sorge dafür, dass links der Eintrag VISUAL C++ markiert ist. Danach wählst durechts WIN32-KONSOLENANWENDUNG.

> Gib dem Projekt einen Namen und sorge dafür, dass hinter SPEICHERORT der Pfadsteht, wo du dein Projekt unterbringen willst. Dann klicke abschließend auf OK.

> Mit einem anschließenden Klick auf FERTIG STELLEN hast du dein erstes Mini-Pro-jekt in C++.

Visual Studio bietet also schon ein Gerüst-Programm, das du natürlich auch startenkannst, allerdings passiert (noch) nichts Aufregendes.

Ich habe das Ganze einfallslos erst mal PROJEKT1 genannt. Du kannst den vor-gegebenen Speicherort übernehmen, ich empfehle dir aber, besser einen eige-nen Ordner zu erzeugen und den dort anzugeben. Bei mir ist das der OrdnerProjekte auf Laufwerk D:.


Das erste Programm

23

> Probiere ruhig mal aus, was sich tut, wenn du in der Menüleiste auf DEBUGGEN

und STARTEN OHNE DEBUGGING klickst. (Alternativ kannst du auch die Tastenkom-bination [Strg]+[F5] drücken.)



24

Vielleicht tut sich nach dem Start des Programms unten im Ausgabe-Fenster etwas,allerdings scheint das für uns derzeit nicht mehr als Kauderwelsch zu sein.

Aber da ist auch noch ein Fenster mit schwarzem Hintergrund, das sich vor VisualStudio schiebt. In dem steht aber nichts weiter als die Aufforderung, eine beliebigeTaste zu drücken.

> Folge dieser Aufforderung (oder Bitte), um das Fenster wieder zu schließen.

Möglicherweise erscheint beim ersten Start ein solches Meldefenster:

Sorge dafür, dass vor dem Eintrag DIESES DIALOGFELD NICHT MEHR ANZEIGEN einHäkchen steht. Dann klicke auf JA.


Der Quelltext

25

Der QuelltextNa ja, überwältigend war deine erste Begegnung mit einem C++-Programm nicht,aber es liegt an dir, daraus etwas zu machen. Zuerst schauen wir uns jetzt dasnäher an, was da links oben im Editorfenster steht:

Das, was du da siehst, wird Quelltext genannt. Die ersten beiden Zeilen mit denbeiden Schrägstrichen (//) am Anfang sind Kommentare. Da könnte man also auchso etwas hinschreiben:

Oder man lässt die beiden Kommentarzeilen einfach ganz weg. Für ein funktionie-rendes Programm sind nur diese Zeilen nötig:

Die erste wichtige Zeile ist diese:

Mit #include sorgen wir dafür, dass etwas in unser Programm eingebunden wird.Aber wozu braucht dieses kleine Programm irgendetwas von außen? Das führt unszur Frage: Was passiert da eigentlich, wenn du auf den »Startknopf« drückst?

So, wie der Quelltext da steht, kann ein Computer damit nichts anfangen. Denn derhat seine eigene Sprache, Maschinensprache genannt, die nur er versteht (undnoch ein paar menschliche Experten). Die Aufgabe von Visual Studio ist es, den füruns lesbaren Quelltext in etwas zu übersetzen, das der Computer »lesen« kann. Dasnennt man Kompilieren und der Teil von Visual Studio, der das übernimmt, heißtCompiler.

// Projekt1.cpp : Definiert den Einstiegspunkt für die Konsolenanwendung.//#include "stdafx.h"

int main(){ return 0;}

// Mein erstes Projekt

#include "stdafx.h"int main(){ return 0;}

#include "stdafx.h"



26

Damit ein Programm richtig funktioniert, sind mehr Zutaten nötig als unser Quell-text. Und damit diese Zutaten mit eingebunden werden, benötigt der Compilereinen Hinweis. Und das ist das Wörtchen #include. Das sorgt dafür, dass dasModul mit dem Namen stdafx.h ins fertige Programm eingefügt wird, damit esnachher auch richtig funktioniert.

> Machen wir einen Test; dazu musst du den Quelltext so ändern:

Nun wird die include-Zeile als Kommentar behandelt, der Compiler überspringtjede Kommentarzeile, als wäre sie gar nicht da.

> Starte das Programm über DEBUGGEN und STARTEN OHNE DEBUGGING oder mit[Strg]+[F5].

Als Erstes bekommst du dieses Meldefenster zu sehen:

> Klicke auf NEIN.

Und nun schauen wir mal nach unten ins Ausgabe-Fenster und suchen dort nacheiner Fehlerliste.

// #include "stdafx.h"int main(){ return 0;}


Der Aufbau eines Programms

27

Dort finden wir den Hinweis, dass offenbar eine Datei namens stdafx.h nötig ist,um das Programm ordnungsgemäß ausführen zu können.

Schon bald wirst du sehen, dass wir noch mehr Zutaten brauchen, wenn wir unserProgramm erweitern.

Der Aufbau eines ProgrammsSchauen wir jetzt mal weiter. Das eigentliche Programm sieht in seiner einfachstenForm so aus:

Damit hat es einen Kopf und einen Rumpf: Der Programmkopf besteht aus derZeile int main(), der Programmrumpf bisher nur aus zwei geschweiften Klam-mern. Man spricht hier auch von Hauptprogramm oder von Hauptfunktion. Daherder Name main.

Die Klammern ({ }) sind sehr wichtig. Sie bilden die Anfangs- und die Ende-Marke.Dazwischen stehen die Anweisungen, die dem Programm erst richtig zum Lebenverhelfen. Und die stammen größtenteils von uns – noch nicht, aber wir sind ja erstam Anfang.

Genau genommen gilt das nur für Visual C++, also wenn du mit Visual Studioarbeitest. Bei anderen Programmsystemen mit C++ gibt es oft gar keinstdafx.h, es wird also nicht benötigt. Warum bei Visual C++? In der Fehlermel-dung steht etwas von »vorkompilierten Headern«. Dazu jetzt nur so viel: Diemachen das Starten des Programms um einiges schneller.

int main(){}

Zu jeder öffnenden Klammer muss es auch eine schließende Klammer geben!Wo genau du hier die Klammern hinsetzt, ist Geschmackssache. Der obige Pro-grammtext könnte also auch so aussehen:

int main() {}

Oder gar so:

int main() { }



28

Wo wir schon beim Thema Klammern sind: Was bedeuten eigentlich die rundenKlammern hinter main? Das gehört zum Konzept von C++. Im Allgemeinen sindAnweisungen, die etwas ausführen sollen, Funktionen.

Und tatsächlich fasst C++ das ganze Programm als eine Funktion auf, nämlich derHauptfunktion (englisch: »main function«). Du hast den Begriff schon weiter obenkennengelernt.

Um eine Erläuterung von int drücke ich mich jetzt noch, doch ich kommebestimmt darauf zurück.

Zu klären wäre aber, was das return bedeutet. Damit gibt die Hauptfunktion amEnde einen Wert zurück. In diesem Fall kann der etwas darüber aussagen, wie gutder Programmlauf geklappt hat, z.B.:

Mit dieser Zeile wird eine 0 ausgegeben, was in der Regel so viel heißt wie »alleso.k.«.

HalloUnd nun wird es Zeit für eine Programmerweiterung, damit auch wir etwas zusehen bekommen.

> Schaue dir den folgenden Quelltext an und tippe ihn genauso ein:

Den Begriff der Funktion solltest du aus dem Mathematik-Unterricht kennen.Du erinnerst dich nicht mehr? Da war doch zum Beispiel bei f(x) »f« der Nameder Funktion und »x« der Name des Arguments, des Wertes also, der an dieFunktion übergeben wird. Und etwas Vergleichbares gibt es auch in C++. EineFunktion übernimmt in Klammern ein Argument, auch Parameter genannt.In unserem Fall gibt es keinen Parameter, deshalb sind hier die Klammern hintermain leer. Aber auch so etwas wäre möglich:

int main(int x){ return x;}

Dann gäbe es einen Parameter namens x.

return 0;


Hallo

29

> Speichere dein Projekt über DATEI und ALLES SPEICHERN. Oder mit der Tastenkom-bination [Strg]+[Shift]+[S].

> Dann starte das Programm mit [Strg]+[F5] oder über DEBUGGEN und STARTEN OHNE

DEBUGGING.

Und wieder öffnet sich ein schwarzes Fenster. Tatsächlich steht dort auch der Gruß»Hallo!«, aber leider wirkt die Aufforderung »Drücken Sie eine beliebige Taste« wiedrangeklebt.

// Mein erstes Projekt#include "stdafx.h"#include <iostream>

int main(){ std::cout << "Hallo!"; return 0;}



30

Dabei hat der Computer genau das getan, was im Quelltext als Anweisung stand:

Was bedeutet: Gib über die Konsole den Text »Hallo!« aus. Das Objekt cout setztsich aus »c« für »console« und »out« zusammen. Mit Konsole (oder Console) ist ebendas schwarze Fenster gemeint, das gerade geöffnet ist.

Wenn du willst, kannst du die Anweisung so ändern:

Dann hat der nachfolgende Text etwas Abstand.

Nach Druck auf eine (beliebige) Taste wird das Programm beendet und das Konso-len-Fenster geschlossen.

cout und cinBevor ich zu weiteren Erklärungen komme, möchte ich das Programm gleich nochetwas erweitern. Dann gibt es für dich auch schon etwas zu tun:

std::cout << "Hallo!";

Genauer gesagt besteht die Konsole aus einem Fenster auf dem Bildschirm(oder dem kompletten Bildschirm) und aus der Tastatur.

Dass das vorgesetzte std eine Abkürzung für »Standard« ist, kannst du dir den-ken, ich komme später darauf zurück.

std::cout << "Hallo! ";

Ist dir aufgefallen, wie jede der beiden Zeilen innerhalb der geschweiften Klam-mern beendet wird? Dieses unscheinbar aussehende Semikolon (;) schließtjede Anweisung ab, darf also nicht vergessen werden!


int main(){ int Name; std::cout << "Hallo, wer da? "; std::cin >> Name; return 0;}


cout und cin

31

> Ändere deinen Quelltext entsprechend, speichere alles und starte dann das Pro-gramm.

> Was du nach der Frage »Hallo, wer da?« eintippst, ist egal. Vergiss nicht, dasGanze mit der [Eingabe]-Taste abzuschließen. (Und natürlich zum Schluss nochmal eine Taste zu drücken.)

Und nun bin ich dir einige Erklärungen schuldig. Beginnen wir mit dem Pärchencout und cin, das ich in einer kleinen Tabelle zusammenfassen möchte:

Beides sind C++-Elemente, die aber nicht im Standard-Modul stdafx.h definiertsind. Dafür brauchen wir ein Extra-Modul, das iostream heißt. Eingebunden wirddie neue Datei mit

iostream ist die Abkürzung für »input-output-stream«, was auf Deutsch so vielwie »Eingabe-Ausgabe-Strom« bedeutet. Somit sind cout und cin auch soge-nannte Datenstrom-Objekte.

Mithilfe von cin und cout lassen sich Daten wie Zahlen und Zeichen übertragen,in diesem Fall über die Standard-Geräte Tastatur und Monitor. Womit wir bei demKürzel std wären, das für »standard« steht. Die beiden Doppelpunkte (::) verbin-den dann das Ganze:

cout Zuständig für die Datenanzeige auf dem Display oder Monitor (= console output)

cin Zuständig für die Datenübernahme von der Tastatur (= console input)

#include <iostream>

Dieses Modul gehört zu den Standard-Bibliotheken von C++. Deshalb verwen-den wir hier spitze Klammern (<>). stdafx.h dagegen wird als Nicht-Stan-dard in Anführungsstriche gefasst (denn das ist eine Besonderheit von VisualC++).

std::cout << "Hallo!";std::cin >> Name;



32

Wie du sehen kannst, lässt sich cin ähnlich wie cout auch mit einem Operatoreinsetzen:

In der ersten Zeile wird der Text "Hallo" an den Ausgabestrom geschickt, der danndafür sorgt, dass dieser Text sichtbar wird. In der zweiten Zeile wartet der Eingabe-strom auf Zeichen von der Tastatur. Der Druck auf die [Eingabe]-Taste besagt, dassdie Eingabe beendet ist.

Weil der "Hallo"-Text fest vorgegeben ist, weiß cout genau, was zu tun ist. Beicin ist das anders, denn zunächst ist ja nicht bekannt, was derjenige, der das Pro-gramm benutzt, eingeben wird.

Deshalb benötigt cin eine Variable, in der die eingetippten Werte gespeichert wer-den können. Die habe ich hier Name genannt, man hätte sie aber auch x nennenkönnen, oder wasweissich.

»Strom« Operator Datenelement Datentransfer

cout << "Hallo" Text A Ausgabe

cin >> Name Eingabe A Variable

Variablen? Vielleicht kennst du den Begriff aus dem Mathe-Unterricht. Mankann dafür auch Platzhalter sagen. Die werden meist mit Buchstaben wie xoder y bezeichnet. Und weil solche Platzhalter in jeder Aufgabe einen anderenWert annehmen können, nennt man so etwas Variablen (das Fremdwort »vari-abel« heißt ja auch so viel wie »veränderlich«).Im Gegensatz dazu gibt es natürlich in C++ auch Konstanten. Die haben danneinen festgelegten Wert, der sich während des Programmlaufs nicht verändert.Und auch bei jedem neuen Programmstart behält eine Konstante ihren Wert.Ein Beispiel ist der Text »Hallo, wer da?« Aber auch Zahlen wie z.B. 0, 1, -1, 3.14lassen sich als Konstanten einsetzen (wie du noch sehen wirst).

Der Name einer Variablen darf übrigens nicht mit einer Ziffer beginnen. An-sonsten kannst du Buchstaben und Ziffern mischen, auch der Unterstrich (_)ist zulässig.

Zum Beispiel sind Name1, A1b2C3, Mein_Name erlaubte Namen für Variablen.Wichtig: C++ unterscheidet zwischen Groß- und Kleinschreibung, Name undNAME ist also nicht dasselbe!

Keinesfalls als Variablennamen benutzt werden dürfen Schlüsselwörter. Dassind Wörter, die nur für den Gebrauch in einer Programmiersprache reserviertsind. Dazu gehören z.B. int und return. Viele weitere wirst du noch im Laufedieses Buches kennenlernen.


Datentypen

33

DatentypenEine Variable muss dem Computer erst bekannt gemacht werden, bevor er sie be-nutzen kann. Mit unbekanntem Zeug schlägt sich der Computer nämlich gar nichterst herum. Man nennt das auch Vereinbarung, womit wir zu dieser Zeile kommen:

Was bedeutet das vorgestellte int? Jede Variable muss mit einem bestimmten Typvereinbart werden. Damit der C++-Compiler aus dem Quelltext ein für den Compu-ter ausführbares Programm machen kann, muss er wissen, womit er es zu tun hat:mit einer Zahl, einer Zeichenkette oder irgendetwas anderem. Denn mit Zahlen z.B.kann der Computer rechnen, mit Zeichen nicht. Das int ist eine Abkürzung für»Integer«, was hier ganze Zahl bedeutet.

Natürlich hast du recht, wenn du jetzt als aufmerksamer Leser sagst: Der Name istdoch keine Zahl. Eigentlich müssten wir die Variable Name also anders vereinbaren,oder? Es handelt sich bei einem Namen ja um einen Text bzw. eine Zeichenfolgeoder Zeichenkette, und das muss der Compiler wissen.

Zeichen werden in C++ char genannt. Das ist eine Abkürzung von »character«.Vereinbaren wir also durch

gleich eine Kette von Zeichen, sagen wir 20. (Wobei das letzte Zeichen intern reser-viert ist. Solltest du längere Namen eingeben wollen, musst du diese Zahl unbe-dingt höher ansetzen.)

Damit sähe unser Programm-Listing jetzt so aus:

Wenn du dieses Programm startest, wirst du keinen Unterschied feststellen. Warum?Weil das Programm gleich nach der Eingabe beendet ist. Man bekommt gar nichtmit, was in der Variablen Name gespeichert wird. Dazu müsste man eine weitereAnweisung mit cout geben – was wir aber jetzt noch nicht tun werden.

int Name;

char Name[20];


int main(){ char Name[20]; std::cout << "Hallo, wer da? "; std::cin >> Name; return 0;}



34

Ich möchte erst einmal eine kleine Änderung vornehmen. Außer dem Typ char gibtes in C++ auch noch den Typ string, was hier so viel wie »Zeichenkette« bedeutet.Das ist deutlich komfortabler als char, u.a. weil string eine flexible Länge er-laubt. Dazu brauchen wir allerdings ein Extra-Modul, das wir gleich mit #includeeinbinden.

Bei der Gelegenheit fügen wir natürlich noch eine cout-Zeile hinzu, in der der ein-gegebene Name auch angezeigt wird. Und hier ist die elegantere Variante unseresProgramms:

Wie angekündigt, wird zuerst die neue Bibliothek für Strings eingebunden:

Dann kommt die Vereinbarung der Variablen Name als string:

Und nach der Eingabe über cin soll dann der Name auch noch mal ausgegebenwerden:

Gibt es Probleme, die Tastenkombinationen für die passenden Klammern zufinden? Dann hilft dir sicher diese kleine Tabelle weiter:

Runde Klammern () [Shift]+[8] ; [Shift]+[9]

Eckige Klammern [] [AltGr]+[8] ; [AltGr]+[9]Geschweifte Klammern {} [AltGr]+[7] ; [AltGr]+[0]

Du wirst künftig noch reichlich Gelegenheit haben, diese Tasten zu benutzen.

// Mein erstes Projekt#include "stdafx.h"#include <iostream>#include <string>

int main(){ std::string Name; std::cout << "Hallo!, wer da? "; std::cin >> Name; std::cout << "Du bist also " << Name << "\n"; return 0;}

#include <string>

std::string Name;


Datentypen

35

Das "\n" am Ende ist ein Steuerzeichen und bedeutet, dass anschließend eineneue Zeile angefangen werden soll (= newline), damit der folgende Text nichtmehr hinten dranklebt. Wie du siehst, muss man hier den Operator << mehrmalsbenutzen.

Bevor du diesen Quelltext eingibst, wollen wir ihn erst noch etwas schlankermachen. Mich stört dieses ständige std, aber es gibt einen Weg, um das Problemzu lösen. Lass einfach das folgende Listing auf dich wirken (A Hallo1):

Sieht doch gleich viel aufgeräumter aus, oder? Dafür sorgt diese Zeile:

Das heißt frei übersetzt so viel wie »Benutzen wir mal den Namensraum std«. Damiterlaubt der Compiler, dass alle Wörter, die zum Standard-Bereich bzw. zum Na-mensraum std gehören, nun ohne Zusatz benutzt werden dürfen.

Wie du in den Zeilen darunter siehst, wirkt der gesamte Quelltext jetzt deutlichaufgeräumter. Stell dir vor, man würde die Anzahl der cout-cin-Zeilen nocherhöhen, dann erspart man sich die ganze Zeit den Zusatz std::.

> Und nun passe deinen Quelltext an, speichere ihn und lass das Programm laufen.

std::cout << "Du bist also " << Name << "\n";

Statt "\n" kann man auch std::endl benutzen, was »end of line« bedeutet.Auch das bewirkt, dass anschließend eine neue Zeile angefangen wird.

// Mein erstes Projekt#include "stdafx.h"#include <iostream>#include <string>using namespace std;

int main(){ string Name; cout << "Hallo!, wer da? "; cin >> Name; cout << "Du bist also " << Name << "\n"; return 0;}

using namespace std;



36

> Gib deinen Namen ein und schaue, ob der Computer ihn sich gemerkt hat. Danndrücke irgendeine Taste, um das Programm zu beenden.

Visual Studio beendenDein allererstes Projekt liegt nun sicher auf einem Datenträger. Und damit wird esZeit für eine kleine Pause.

> Um Visual Studio zu verlassen, klicke auf DATEI und dann auf BEENDEN.

> Oder du drückst die Tastenkombination [Alt]+[F4]. Du kannst auch im Haupt-fenster ganz oben rechts auf das kleine X klicken. Irgendwie kommst du alsoimmer »nach Hause«.

Sollte sich vor dem letzten Speichern noch etwas verändert haben, bekommst dudieses Meldefenster zu sehen:


Zusammenfassung

37

Dort werden alle Dateien aufgelistet, an denen eine Änderung vorgenommenwurde. In unserem Fall ist das nur eine Datei.

> Klicke auf JA, um deine letzte Version zu speichern.

ZusammenfassungMit deinem ersten Projekt gehörst du zwar noch nicht zur Zunft der C++-Program-mierer, aber die Anfangsschritte hast du hinter dir. Mal sehen, was du von diesemKapitel behalten hast. Da wären zuerst mal ein paar Optionen im Umgang mit VisualStudio:

Dein C++-Wortschatz ist zwar noch nicht allzu groß, aber einiges an Wörtern undZeichen kennst du schon:

Wie du siehst, hat die Datei die Kennung cpp, was für »C-plus-plus« steht.

Visual Studio starten Doppelklicke auf das Visual-Studio-SymbolGanzes Projekt speichern

Klicke auf DATEI/ALLES SPEICHERN.

Programmprojekt starten

Klicke auf DEBUGGEN/STARTEN OHNE DEBUGGING oder drücke [Strg]+[F5].

Programmprojekt beenden

Drücke eine Taste oder klicke auf das X am Konsolen-Fenster.

Visual Studio beenden Klicke auf DATEI/BEENDEN.

#include Ein Modul einbindenstd Namensraum für Standard-Moduleusing namespace Namensraum festlegen



38

Und du hast auch schon ein paar Module eingebunden, die C++ zusätzlich zumProgramm benötigt:

Ein paar Fragen ...1. Wie setzt man in einem C++-Programm Marken für Anfang und Ende?

2. Was genau ist der Unterschied zwischen cin und cout?

3. Wie bindet man zusätzliche Module in ein Programm ein?4. Was passiert, wenn man als Typ für die Variable Name statt string wieder int

benutzt?

... und eine Aufgabe1. Setze das »Gespräch« mit cout und cin fort. Wenn du willst, kannst du die

Variable Name weiter benutzen, ihr Inhalt wird allerdings mit jeder neuen Ein-gabe überschrieben. Wenn du das nicht willst, vereinbare neue Variablen.

char, char[] Einzelzeichen oder Zeichenketteint Ganze Zahlstring Zeichenkettemain() Hauptfunktion, Hauptprogrammreturn Wert zurückgebencout Objekt für die Ausgabe, »Datenstrom«cin Objekt für die Eingabe, »Datenstrom«<< Operator für »Verschiebung« nach links (hier

Ausgabestrom)>> Operator für »Verschiebung« nach rechts (hier

Eingabestrom){ } Klammern für Anfang-Ende-Marken( ) Klammern für Parameter< > Klammern für Standard-Modul// Kommentarzeichen; Abschluss einer Anweisung

stdafx Spezielles Visual-C++-Modul für alle Programmeiostream Modul für Eingabe/Ausgabe-Operationenstring Modul für den Einsatz von Zeichenketten


393

Stichwortverzeichnis

: 31, 157! 126* 141\0 137\n 35& 117, 140&& 75#include 25<< 32, 208-> 188>> 32, 208|| 753 Punkte 235

AAdressoperator 140Anfangsmarke 27Anweisungsblock 67Anzeigeebene 363ä-ö-ü-ß 46areaCollision 324, 366argc 226Argumente 226argv 226Array

dynamisch 196Parameter 331statisch 125

Array-Grenzen 129atan2 268auto 199

BBedingung 67begin 205Bereichsbasierte Schleife 198

Bezeichner 93, 106Binärsystem 138, 349Bindung

dynamisch 185statisch 185

Bit 138, 349Boden 345bool 44, 113bounce 366break 79, 93Bug 390Byte 136, 138, 349

Ccase 77Casting 223, 362, 374catch 232cerr 234char 33, 44, 98, 225char[] 226cin 31, 44CircleShape 247, 249, 318class 152clear 211Clock 280close 209, 247Color 247, 348Community 379Compiler 12, 25, 182const 57, 230Container

list 201Typ 196vector 196

contains 323continue 94controlRange 299, 343


394


cout 30, 31, 41fixed 54setprecision 54

cpp 37, 63, 161C-String 225, 234

DDatenstrom 31, 208Datenstruktur 132, 148Datenverkehr 207Debug 241

beenden 392Einzelschritt 391Haltepunkt 392Prozedurschritt 390

Debugger 232, 235, 390default 79Default-Parameter 216Definition 43Deklaration 40delete 189delete[] 192Destruktor 190, 219, 333Dezimalsystem 138Dezimalzahl 41, 44DLL 243Dodging 322Doppelpunkt 173, 199double 44do-while 88draw 284Dummy 303Dummy-Parameter 230Durchgangsparameter 117Dynamische Bindung 185Dynamisches Linken 243

EEbene des Objekts 363Editor 12Einzelschritt (Debug) 391Element 134

statisch 355Elementfunktionen 152Elementvariablen 152else 68

end 205Endemarke 27endl 35Endlosschleife 94Entwicklungsumgebung 12enum 57, 313erase 204Error 26, 59, 65, 93, 293evaluateGame 106Event 247, 373Exception 233

FFallunterscheidung 77Farbe 349Fehler 26, 59, 65, 93, 232, 242Feld 125

Initialisierung 126Feldvariable 125find 224fixed 54float 41, 44FloatRect 323Font 281for 90, 198Formatierung 54Frühe Bindung 185fstream 207Funktion 28

eigene 102Rückgabe 112statisch 222überladen 178überschreiben 183virtuell 184

Funktionskopf 103Funktionsprototyp 120Funktionsrumpf 104Funktions-Template 230

GGame-Klasse 292Ganze Zahl 33getElapsedTime 280getGlobalBounds 323getLocalBounds 347



395

getPosition 257, 265getScore 295getTextureRect 256, 319getTime 296Gizmo 354GlobalBounds 323Globale Variable 93, 107Gravitation 335, 370Groß-Kleinschreibung 32Ground 345Grundfarben 349Gültigkeitsoperator 157

Hh 161Haltepunkt (Debug) 392Hauptprogramm 27Header 161Hex 139Hexadezimalsystem 138Hilfe 390Himmel 345Hindernis 364Hintergrund 345hpp 246Hypotenuse 179

Iif 65ifstream 208include 25Index 125initArea 346initGame 105Initialierung

Sprite 356Initialisierung

Feld 126Funktion 151Spiel 105Sprite 298Startwerte 105Zählschleife 91

initMessage 294initShape 318initSprite 298

insert 204Installation 379Instanz 134, 153int 33, 44intersects 323Intervall 75IntRect 256iomanip 54iostream 31, 41isButtonPressed 265isKeyPressed 254isKilled 279isLethal 374isObstacle 355isOpen 247isPickable 355Iterator 204

JJoystick 270jump 370Jump & Run 330

KKapselung 152, 193Keyboard 254KeyPressed 254Keypressed 373KeyReleased 373Klammer

Position 73Klammern

eckige [] 125geschweift 27rund 28spitz 31

Klasse 152Klassen-Template 202Kollision 276, 299, 321Kommentar 25Kompilieren 25, 182Konsole 30Konstante 32, 56Konstruktor 156, 190, 216, 294, 333Kontakt 275, 299, 321Kontrollstruktur 67, 69, 77, 85, 91, 199


396


LLeerkette 151LIB 244Linken

dynamisch 243statisch 243

Linker 240list 201loadFromFile 250, 281LocalBounds 347locale::global 46, 83Lokale Variable 93, 107long 44

Mmain 226main() 27Marke Anfang-Ende 27Maschinensprache 25Mathematik 48Methoden 152Modifizierer 44Modulo 84Mouse 265MouseButtonPressed 265move 253move (Player) 299

Nnamespace 35, 246new 186, 221, 305new[] 191newline 35Nicht-Operator 126NULL 83nullptr 141Nullzeichen 137Nullzeiger 141

OObjekt 153

Datenstrom 31dynamisch 189Ebene 363

Objektorientierte Programmierung 153ofstream 208OOP

Kapselung 153Vererbung 172

Operator 50- / 50! 126, 279!= 69. 134, 306* 141& 117, 140&& 75, 273% 84+ * 49++ , -- 52+= , -= 51< , <= 72<< 32, 208= 51== 65-> 188, 306>, >= 72>> 32, 208|| 75, 273binär 228const 230Datei 208Pfeil 188Punkt 134, 159, 188Scope 157static_cast 132string+ 55überladen 227unär 228Vergleich 71Verkettung 56Verknüpfung 74Zeiger 141

operator 228Operator:: 157

Ppaint.net 251Panda3D 377Parameter 28, 110

Array 331



397

const 230Dummy 230Referenz 117Wert 116

Pfeil-Operator 188Pixel 246Player

Tod 374Player-Klasse 296playGame 105PNG 250Pointer 140pollEvent 247Polymorphie 185, 193pop_back 198Popup 20pragma once 162private 160Programm

Kopf 27Rumpf 27starten 23

Programmiersprache 12Projekt

Aufbau 28Duplikat 64neu 21, 41öffnen 62schließen 47speichern 29starten 23

Projektmappen-Explorer 48protected 177Prototyp 120Prozedur 391Prozedurschritt (Debug) 390public 155Punkte 284Punkt-Operator 134, 159, 188push_back 198Pythagoras 267

QQuadratwurzel 267Quelltext 25

RRainbow 361rand 84, 271read 209Rechenarten 49Rechenoperator 50Rechnen 48Rect 323RectangleShape 249Referenz 199Referenzparameter 117remove 203Rendern 247RenderWindow 246restart 280return 28Rückgabewert 112

SSchalt-Funktion 113Schalt-Variable 113Schleife 85

bereichsbasiert 198Schlüsselwort 32, 95Schlüsselwörter 102Schriftart 281Schriftfarbe 283Schriftgröße 283Scope-Operator 157SDL-Paket 238Semikolon 30setCharacterSize 283setDeath 300setDirection 298setFillColor 247, 318setFont 283setMessage 295setOrigin 255setOutlineColor 318setPosition 247, 251, 283setprecision 54setRotation 255setScale 251setScore 295setSpeed 298setState 314


398


setString 283setTexture 250Setup 18sf 246SFML

Bewegung 253clear 247Color 247display 247draw 247Drehung 255Fenster 246graphics-d 240include 239installieren 385Kreis 247lib 239Mittelpunkt 256move 253, 268Position 251, 257Skalierung 251sprite 250system-d 240Tastatur 253Text 281texture 250Vielecke 249window-d 240

SFML-Paket 238Shape 318, 345shape 247signed 44size 224sizeof 209Sky 345sleep 272, 319sln-Datei 63Späte Bindung 185Spielfeld 249Spielfigur 249spotCollision 299, 322Sprite 250sqrt 179, 267srand 84, 271Standardparameter 216static 219static_cast 132Statisch 218

Statische Bindung 185Statisches Element 218, 355Statisches Linken 243std 31stdafx.h 26stdlib 83Steuerzeichen 35, 140stoi 225strcat 226strcpy 226string 34, 44, 284struct 132, 148Struktur 132substr 224switch 77, 314, 375

TTabulator 140Template 323

Funktion 230Klasse 196, 230

Textur 250TextureRect 323Texturwechsel 367throw 233Tilde 190, 220Time 280time 83Timer 279to_string 130, 223, 284Transparenz 250, 253, 350Treffer 279try 232turn (Player) 299Typecasting 132typedef 323

UÜberladen

Funktion 178Konstruktor 177Operatoren 227

Überschreiben 183Umkehr-Operator 279Umlaute 46Und-Operator 74



399

unsigned 44using 35, 246

VVariable 32, 40

global 93, 107lokal 93, 107statisch 220

Variablenfeld 125vector 196Vector2 258, 265Vector3 258Vektor 196, 249Vereinbarung 50Vererbung 172, 193Vergleichsoperator 65Verkettete Liste 201Verkettung 56Verknüpfung 19Verknüpfungsoperator 75virtual 184, 190Virtuelle Funktion 184Visual Studio 12

beenden 36Fenstergruppe 20installieren 379Menüs 20neues Projekt 20Projektstart 23

speichern 29starten 18Verknüpfung 19

void 104

WWerteparameter 116while 85, 212Winkelfunktion 268Wortschatz 102write 209

ZZahl

ganze 33Zahlenraten 83Zählschleife 91, 199Zeichenkette 33Zeiger 140, 305

nächster 191Zeigermathematik 191, 205Zeigeroperator 141, 144Zufall 270Zufallsgenerator 83Zufallszahl 82, 84Zugriffsoperator 134, 158, 188Zuweisung 41, 50Zuweisungsoperator 65


Documents

C++ für Kids - mitp · In diesem Buch hast du es mit der Programmiersprache C++ zu tun. Sie ist seit vie-len Jahren sehr weit verbreit et, allerdings nicht leicht zu erlernen. Dafür