C++ für Spieleprogrammierer
von: Heiko Kalista
Carl Hanser Fachbuchverlag, 2005
ISBN: 9783446400658
Sprache: Deutsch
482 Seiten, Download: 4133 KB
Format: PDF, auch als Online-Lesen
Inhalt | 8 | ||
Geleitwort | 16 | ||
Vorwort | 17 | ||
Danksagung | 19 | ||
1 Grundlagen | 20 | ||
1 Grundlagen | 21 | ||
1.1 Einleitung | 21 | ||
1.1.1 An wen richtet sich dieses Buch? | 21 | ||
1.1.2 Welche Vorkenntnisse werden benötigt? | 21 | ||
1.1.3 Wie arbeitet man am effektivsten mit diesem Buch? | 21 | ||
1.1.4 Geduld, Motivation und gelegentliche Tiefschläge | 22 | ||
1.1.5 Die beigelegte CD | 24 | ||
1.1.6 Fragen zum Buch | 24 | ||
1.2 Die Programmiersprache C++ | 24 | ||
1.2.1 Von Lochkarten zu C++ | 24 | ||
1.2.2 Objektorientiertes Programmieren | 26 | ||
1.2.3 Der ANSI-Standard | 26 | ||
1.2.4 Warum gerade C++? | 27 | ||
1.3 Jetzt geht es los...unser erstes Programm | 28 | ||
1.3.1 Kommentare im Quelltext | 29 | ||
1.3.2 Die #include-Anweisung | 30 | ||
1.3.3 Die main-Funktion | 32 | ||
1.3.4 Der „Befehl“ cout und einige mögliche Escape-Zeichen | 33 | ||
1.4 Die Entwicklungsumgebung | 34 | ||
1.4.1 Erstellen eines neuen Arbeitsbereiches mit Microsoft Visual C++ 6.0 | 35 | ||
1.4.2 Erstellen eines neuen Arbeitsbereiches mit Microsoft Visual C++ . NET 2003 | 36 | ||
1.4.3 Das Programm mit Hilfe des Quelltexteditors eingeben | 37 | ||
1.4.4 Laden der Programmbeispiele von CD | 38 | ||
1.4.5 Das Programm kompilieren, linken und ausführen | 38 | ||
1.4.6 Ausführen des Programms | 41 | ||
1.4.7 Der Unterschied zwischen Debug und Release | 42 | ||
1.5 Aufgabe | 43 | ||
2 Variablen | 46 | ||
2 Variablen | 47 | ||
2.1 Was sind Variablen, und wozu dienen sie? | 47 | ||
2.2 Datentyp, Variablenname und Wert | 47 | ||
2.3 Deklarieren und definieren von Variablen | 48 | ||
2.4 Rechnen mit Variablen | 51 | ||
2.4.1 Weitere Rechenoperatoren | 53 | ||
2.5 Die verschiedenen Datentypen | 55 | ||
2.6 Namenskonventionen | 57 | ||
2.7 Konstanten | 58 | ||
2.7.1 Konstanten mit „const“ erzeugen | 59 | ||
2.7.2 Konstanten mit „#define“ erzeugen | 59 | ||
2.7.3 Konstanten mit „enum“ erzeugen | 60 | ||
2.7.4 Welche der drei Möglichkeiten ist die Beste? | 61 | ||
2.8 Mach mal Platz: Speicherbedarf der Datentypen | 61 | ||
2.8.1 Überlauf von Variablen | 63 | ||
2.9 Eingabe von Werten mit „cin“ | 64 | ||
2.10 Casting: Erzwungene Typenumwandlung | 66 | ||
2.10.1 Casting im C-Stil | 67 | ||
2.10.2 Casting mit C++ | 68 | ||
2.11 Fehlerquelltext | 70 | ||
2.11.1 Was soll das Programm eigentlich tun? | 70 | ||
2.11.2 Lösung zum Fehlerquelltext | 71 | ||
3 Schleifen und Bedingungen | 76 | ||
3 Schleifen und Bedingungen | 77 | ||
3.1 Was sind Schleifen und Bedingungen, und wozu dienen sie? | 77 | ||
3.2 Boolesche Operatoren (==, <, >, !=) | 77 | ||
3.3 Die if-Bedingung | 79 | ||
3.4 Mittels „else“ flexibler verzweigen | 81 | ||
3.5 else if und verschachtelte if-Bedingungen | 83 | ||
3.6 Logische Operatoren | 87 | ||
3.7 Verzweigen mit switch und case | 89 | ||
3.8 Immer und immer wieder: for-Schleifen | 92 | ||
3.8.1 Initialisierungsteil | 94 | ||
3.8.2 Bedingungsteil | 94 | ||
3.8.3 Aktionsteil | 95 | ||
3.8.4 Zusammenfassung | 95 | ||
3.9 Eine weitere Rechenoperation: Modulo | 96 | ||
3.10 Aufgabenstellung | 97 | ||
3.10.1 Wie geht man an die Aufgabe heran? | 97 | ||
3.10.2 Lösungsvorschlag | 98 | ||
3.11 Schleifen mit while und do-while | 100 | ||
3.12 Verschachtelte Schleifen | 103 | ||
3.13 Fehlerquelltext | 104 | ||
3.13.1 Was soll das Programm eigentlich tun? | 105 | ||
3.13.2 Lösung zum Fehlerquelltext | 106 | ||
4 Funktionen | 110 | ||
4 Funktionen | 111 | ||
4.1 Was sind Funktionen, und wozu dienen sie? | 111 | ||
4.2 Aufbau des Funktionskopfes | 113 | ||
4.2.1 Rückgabetyp | 113 | ||
4.2.2 Funktionsname | 113 | ||
4.2.3 Parameterliste | 114 | ||
4.3 Aufrufen einer Funktion | 114 | ||
4.3.1 Funktionsprototypen | 114 | ||
4.4 Gültigkeitsbereiche | 116 | ||
4.4.1 Lokale Variablen | 117 | ||
4.4.2 Globale Variablen | 117 | ||
4.4.3 Das wäre ja zu einfach gewesen: globale Variablen am Pranger | 118 | ||
4.5 Verwenden der Funktionsparameter | 118 | ||
4.5.1 Der Stack | 120 | ||
4.6 inline-Funktionen | 122 | ||
4.7 Wann setzt man Funktionen ein? | 124 | ||
4.7.1 Und wann soll’s inline sein? | 125 | ||
4.8 Überladene Funktionen | 126 | ||
4.9 Aufgabenstellung | 130 | ||
4.9.1 Wie geht man an die Aufgabe heran? | 130 | ||
4.9.2 Lösungsvorschlag | 131 | ||
4.10 Der sinnvolle Aufbau des Quellcodes | 132 | ||
4.11 Erstellen und Hinzufügen der neuen Dateien | 133 | ||
4.12 Das Schlüsselwort „extern“ | 136 | ||
4.13 Ein kleines Spiel: Zahlenraten | 137 | ||
4.13.1 Zufallszahlen und Bibliotheksdateien | 142 | ||
4.13.2 Die Hauptfunktion (main) | 144 | ||
4.13.3 Die Funktion „WaehleLevel“ | 145 | ||
4.13.4 Die Funktion „Spielen“ | 145 | ||
4.13.5 Was gibt es an diesem Listing zu kritisieren? | 146 | ||
5 Arrays und Strukturen | 148 | ||
5 Arrays und Strukturen | 149 | ||
5.1 Was sind Arrays, und wozu dienen sie? | 149 | ||
5.2 Ein Array erzeugen | 149 | ||
5.3 Ein Array gleichzeitig deklarieren und definieren | 151 | ||
5.4 Fehler beim Verwenden von Arrays | 153 | ||
5.5 char-Arrays | 153 | ||
5.6 Eingabe von Strings über die Tastatur | 155 | ||
5.7 Mehrdimensionale Arrays | 157 | ||
5.8 Arrays und Speicherbedarf | 159 | ||
5.9 Was sind Strukturen, und wozu dienen sie? | 159 | ||
5.10 Spielerverwaltung mit Strukturen und Arrays | 162 | ||
5.11 Aufgabenstellung | 165 | ||
5.11.1 Wie geht man an die Aufgabe heran? | 166 | ||
5.11.2 Lösungsvorschlag | 167 | ||
6 Zeiger und Referenzen | 172 | ||
6 Zeiger und Referenzen | 173 | ||
6.1 Was sind Zeiger, und wozu dienen sie? | 173 | ||
6.1.1 Der Stack | 174 | ||
6.1.2 Vom Flur in den Keller | 175 | ||
6.2 Die Adresse einer Variablen | 176 | ||
6.3 Die Adresse einer Variablen in einem Zeiger speichern | 178 | ||
6.3.1 Schreibweisen bei der Deklaration | 180 | ||
6.4 Variablen mittels Zeigern ändern | 181 | ||
6.5 Schön und gut, aber wozu wird das gebraucht? | 182 | ||
6.6 Noch einmal zurück zum Flur | 185 | ||
6.7 Was sind Referenzen, und wozu dienen sie? | 187 | ||
6.7.1 Mit Referenzen arbeiten | 188 | ||
6.7.2 Regeln bei der Verwendung von Referenzen | 189 | ||
6.8 Referenzen als Funktionsparameter | 190 | ||
6.9 Warum Zeiger nehmen, wenn es Referenzen gibt? | 192 | ||
6.10 Aufgabenstellung | 194 | ||
6.10.1 Wie geht man an die Aufgabe heran? | 195 | ||
6.10.2 Lösungsvorschlag | 196 | ||
7 Klassen | 200 | ||
7 Klassen | 201 | ||
7.1 Was sind Klassen, und wozu dienen sie? | 201 | ||
7.2 Eine einfache Klasse erzeugen und verwenden | 203 | ||
7.3 Ordnung muss sein | 206 | ||
7.4 Jetzt wird es privat | 208 | ||
7.4.1 Private Membervariablen | 209 | ||
7.4.2 Private Membervariablen und Performance | 211 | ||
7.4.3 Private Memberfunktionen | 212 | ||
7.5 Konstruktoren und Destruktoren | 213 | ||
7.5.1 Der Konstruktor | 213 | ||
7.5.2 Konstruktoren mit Parameterliste | 215 | ||
7.5.3 Überladene Konstruktoren | 217 | ||
7.6 Der Destruktor | 219 | ||
7.7 Speicherreservierung | 221 | ||
7.7.1 New und Delete | 222 | ||
7.7.2 Ein sinnvolleres Beispiel | 223 | ||
7.7.3 Friss mich, ich bin Dein Speicher | 226 | ||
7.8 Aufgabenstellung | 228 | ||
7.8.1 Wie geht man an die Aufgabe heran? | 229 | ||
7.8.2 Lösungsvorschlag | 230 | ||
7.9 Vererbung | 232 | ||
7.9.1 Überschreiben von Memberfunktionen | 238 | ||
7.9.2 Virtuelle Memberfunktionen | 241 | ||
7.9.3 Vererbung und Performance | 245 | ||
7.10 Statische Membervariablen | 246 | ||
8 Fortgeschrittene Themen | 250 | ||
8 Fortgeschrittene Themen | 251 | ||
8.1 Über dieses Kapitel | 251 | ||
8.2 printf und sprintf | 251 | ||
8.2.1 printf | 251 | ||
8.2.2 sprintf | 253 | ||
8.3 Templates | 255 | ||
8.3.1 Template-Funktionen | 256 | ||
8.3.2 Template-Klassen | 258 | ||
8.4 Singletons | 262 | ||
8.4.1 Eine Klasse für Singletons | 262 | ||
8.4.2 Einsatz von Singletons | 264 | ||
8.5 Dateien: Ein- und Ausgabe | 267 | ||
8.5.1 Werte in eine Datei schreiben und auslesen | 267 | ||
8.5.2 So viel Zeit muss sein: Fehlerabfrage | 269 | ||
8.5.3 Instanzen von Klassen in Dateien schreiben | 271 | ||
8.5.4 Weitere Flags und ihre Bedeutung | 273 | ||
8.6 Eine nützliche Logfile-Klasse | 274 | ||
8.6.1 Die Header-Datei der Logfile-Klasse | 274 | ||
8.6.2 Die Implementierung der Logfile-Klasse | 277 | ||
8.6.3 Anwendung der Logfile-Klasse | 283 | ||
8.7 Try, Catch und Assert | 285 | ||
8.7.1 Das Makro „assert“ | 285 | ||
8.7.2 Fang mich, wenn Du kannst: try und catch | 288 | ||
8.8 Der Debugger | 290 | ||
8.8.1 Das Programm im Einzelschrittmodus durchlaufen | 290 | ||
8.8.2 Haltepunkte und Funktionsaufrufe | 293 | ||
8.9 SAFE_DELETE - Ein nützliches Makro | 296 | ||
9 Die STL | 298 | ||
9 Die STL | 299 | ||
9.1 STL – was ist das? | 299 | ||
9.1.1 Vektoren | 299 | ||
9.1.2 Verkettete Listen | 306 | ||
9.1.3 Strings | 316 | ||
9.1.4 Maps und Multimaps | 322 | ||
10 Grundlagen der Windows- Programmierung | 332 | ||
10 Grundlagen der Windows-Programmierung | 333 | ||
10.1 Raus aus der Konsole, rein ins Fenster | 333 | ||
10.1.1 Anlegen eines Win32-Projektes | 333 | ||
10.1.2 Ein Windows-Grundgerüst | 334 | ||
10.1.3 Die WinMain-Funktion | 337 | ||
10.1.4 Die Callback-Funktion | 345 | ||
10.1.5 Zusammenfassung | 347 | ||
10.1.6 Ein kurzer Abstecher: Funktionszeiger | 348 | ||
10.2 Aufgabenstellung | 351 | ||
10.2.1 Wie geht man an die Aufgabe heran? | 351 | ||
10.2.2 Lösungsvorschlag | 353 | ||
10.3 Ein bisschen mehr Interaktion | 355 | ||
10.3.1 Statischer Text | 355 | ||
10.3.2 Buttons und Editboxen | 357 | ||
10.3.3 Messageboxen | 358 | ||
10.4 Alles noch einmal zusammen | 360 | ||
11 Sonst noch was? | 370 | ||
11 Sonst noch was? | 371 | ||
11.1 Um was geht es in diesem Kapitel? | 371 | ||
11.2 Standardwerte für Funktionsparameter | 372 | ||
11.3 Memberinitialisierung im Konstruktor | 374 | ||
11.4 Der this-Zeiger | 379 | ||
11.5 Der Kopierkonstruktor | 384 | ||
11.6 Überladen von Operatoren | 389 | ||
11.7 Mehrfachvererbung | 394 | ||
11.8 Friend-Klassen | 399 | ||
12 Ein Spiel mit der SDL | 406 | ||
12 Ein Spiel mit der SDL | 407 | ||
12.1 Die SDL – was ist das? | 407 | ||
12.2 Erstellen und Einrichten des Projektes | 408 | ||
12.2.1 Projekt mit Microsoft Visual C++ 6.0 anlegen | 409 | ||
12.2.2 Projekt mit Microsoft Visual C++ .net 2003 anlegen | 409 | ||
12.2.3 Die restlichen Quellcode-Dateien | 410 | ||
12.3 Projektübersicht | 411 | ||
12.3.1 Wieso plötzlich Englisch? Und wo sind die Zeilennummern? | 412 | ||
12.3.2 Übersicht der Klassen | 412 | ||
12.4 Die Implementierung des Spiels | 414 | ||
12.4.1 Die main-Funktion des Spiels | 414 | ||
12.4.2 Zeit ist wichtig: die Klasse CTimer | 416 | ||
12.4.3 Die Klasse CFramework | 418 | ||
12.4.4 Bunte Bilder: die Klasse CSprite | 426 | ||
12.4.5 Feuer frei: die Klasse CShot | 435 | ||
12.4.6 Die Klasse CAsteroid | 438 | ||
12.4.7 Die Hauptfigur: die Klasse CPlayer | 441 | ||
12.4.8 Die Klasse CGame | 448 | ||
12.5 Erweiterungsmöglichkeiten | 457 | ||
13 Der Einstieg in die Szene | 460 | ||
13 Der Einstieg in die Szene | 461 | ||
13.1 Wie geht’s nun weiter? | 461 | ||
13.2 Die Szene...was ist das eigentlich? | 462 | ||
13.3 Welche Möglichkeiten gibt es? | 463 | ||
13.4 Foren benutzen | 464 | ||
13.4.1 Ich sag Dir wer ich bin | 464 | ||
13.4.2 Richtig posten | 464 | ||
13.4.3 FAQs und die Suchfunktion | 467 | ||
13.4.4 Die Kunst zu lesen | 467 | ||
13.4.5 Selbst Initiative ergreifen und anderen helfen | 468 | ||
13.5 Weiterbildung mit Tutorials | 468 | ||
13.6 Anlegen einer Linksammlung | 469 | ||
13.7 Copy & Paste | 470 | ||
13.8 Die Sprache neben C++: Englisch | 471 | ||
13.9 Auf dem Weg zum eigenen Spiel | 471 | ||
13.9.1 Mein erstes Spiel: ein 3D-online-Rollenspiel für 500 Leute | 471 | ||
13.9.2 Teammitglieder suchen | 472 | ||
13.9.3 Das fertige Spiel bekannt machen | 473 | ||
13.9.4 Besuchen von Events zum Erfahrungsaustausch | 473 | ||
13.10 return 0 | 474 | ||
Index | 476 | ||
Mehr eBooks bei www.ciando.com | 0 |