492.txt ************************************************************************ * Edit v1.003 from 2021-11-11 to 2022-10-01 by HSc+MSc * ************************************************************************ C++: Eine kompakte Einfuehring Wilms, Andre' dpunkt.verlag, 1. Auflage 2015 3-86490-229-1 Seite Auszug ===== ================================================================ 001 1 Einfuehrung ------------------------------------------------------------------------ 001 1.1 UEber das Buch ------------------------------------------------------------------------ 001 C++14 001 Objektorientierte Programmierung 002 1.2 Vorstellung des Projekts ------------------------------------------------------------------------ 003 1.3 Identifizieren der Programmteile ------------------------------------------------------------------------ 004 1.3.1 Objekte ------------------------------------------------------------------------ 004 1.3.2 Kontrollstrukturen ------------------------------------------------------------------------ 004 1.4 Abstraktion ------------------------------------------------------------------------ 005 1.4.1 Datenabstraktion ------------------------------------------------------------------------ 005 1.4.2 Algorithmische Abstraktion ------------------------------------------------------------------------ 005 Algorithmus Ein Algorithmus ist eine Menge von Regeln, durch deren Befolgung in festgeleigter Reihenfolge ein bestimmtes Problem geloest wird. 007 Dabei werden Algorithmen in der Weise formuliert, die auch Personen ohne Fachkenntnis das Loesen des Problems ermoeglichen. Dies setzt eine Beschreibung mit moeglichst klein gehaltenen Vokabular voraus. Programm Ein Algorithmus der fuer einen Computerverstaendlich formuliert wurde, nennt man Programm. 009 2 Grundelemente eines C++-Programms ------------------------------------------------------------------------ 009 2.1 Das erste Programm ------------------------------------------------------------------------ 010 2.1.1 Implizites return ------------------------------------------------------------------------ 010 2.2 Die Ausgabe ------------------------------------------------------------------------ 011 2.2.1 cout ------------------------------------------------------------------------ 013 2.3 include ------------------------------------------------------------------------ 013 endl -> to flush 014 2.4 Namensbereiche ------------------------------------------------------------------------ 014 std::cout ... std = Vorwahl, cout = Telefonnummer using namespace std; 016 2.5 Kommentare ------------------------------------------------------------------------ 017 C: Praeprozessor & /* ... */ c** 6 // ... 018 2.6 Escape-Sequenzen ------------------------------------------------------------------------ 018 /f -> Seitenforschub 018 2.7 Zusammenfassung ------------------------------------------------------------------------ 019 2.8 Spielprojekt ------------------------------------------------------------------------ 021 3 Arithmetik in C++ ------------------------------------------------------------------------ 021 3.1 Variablen ------------------------------------------------------------------------ 022 3.1.1 Integrierte Datentypen ------------------------------------------------------------------------ 023 3.1.2 Vorzeichenlose Typen ------------------------------------------------------------------------ 023 3.2 Definieren einer Variablen ------------------------------------------------------------------------ 024 3.2.1 Initialisierung ------------------------------------------------------------------------ 025 3.2.2 Lebensdauer ------------------------------------------------------------------------ 025 3.2.3 Automatische Typbestimmung ------------------------------------------------------------------------ 025 auto b=3.14 -> double decltype(b) c; -> double 026 3.2.4 Definitionen zusammenfassen ------------------------------------------------------------------------ 027 3.3 Eingabe ------------------------------------------------------------------------ 027 Standardmaeszig betrachtet cin Whitespaces (wie Leerzeichen, Tabulatoren, Newline, Enter, etc.) als Trenner zwischen Eingaben. 028 3.4 Grundrechenarten ------------------------------------------------------------------------ 030 3.5 Konstanten ------------------------------------------------------------------------ 030 3.5.1 Konstante Ausdr?cke ------------------------------------------------------------------------ 031 3.5.2 Unveraenderliche Werte ------------------------------------------------------------------------ 031 3.6 Restwert ------------------------------------------------------------------------ 032 3.7 Verkn?pfen unterschiedlicher Datentypen ------------------------------------------------------------------------ 033 3.8 Explizite Typumwandlung ------------------------------------------------------------------------ 034 3.9 Kombinierte Zuweisungsoperatoren ------------------------------------------------------------------------ 035 3.10 Inkrement und Dekrement ------------------------------------------------------------------------ 035 3.11 Mathematische Funktionen ------------------------------------------------------------------------ 035 Tab. 3.3 Die Funktione der Headerdatei cmath.h HSc: Quadrieren, Potenzieren mit double pow(double a, double b) nach dem Muster a hoch b; 036 3.12 Bitweise Operatoren ------------------------------------------------------------------------ 039 3.13 Zusammenfassung ------------------------------------------------------------------------ 040 3.14 Spielprojekt ------------------------------------------------------------------------ 043 4 Verzweigungen ------------------------------------------------------------------------ 043 4.1 Zusammengesetzte Anweisungen ------------------------------------------------------------------------ 044 4.2 Bedingungen ------------------------------------------------------------------------ 045 4.3 if ------------------------------------------------------------------------ 047 4.4 eise ------------------------------------------------------------------------ 048 4.5 Logische Operatoren ------------------------------------------------------------------------ 051 4.6 Der ?:-Operator ------------------------------------------------------------------------ 052 4.7 Die Fallunterscheidung ------------------------------------------------------------------------ 055 4.8 static_assert ------------------------------------------------------------------------ 055 4.9 assert ------------------------------------------------------------------------ 057 4.10 Zusammenfassung ------------------------------------------------------------------------ 057 4.11 Spielprojekt ------------------------------------------------------------------------ 059 5 Schleifen ------------------------------------------------------------------------ 059 5.1 while ------------------------------------------------------------------------ 061 5.2 do-while ------------------------------------------------------------------------ 062 5.3 for ------------------------------------------------------------------------ 064 5.4 break ------------------------------------------------------------------------ 065 5.5 continue ------------------------------------------------------------------------ 066 5.6 Zusammenfassung ------------------------------------------------------------------------ 066 5.7 Spielprojekt ------------------------------------------------------------------------ 067 6 Funktionen - ???*???? - ------------------------------------------------------------------------ 067 6.1 Funktionsdefinition ------------------------------------------------------------------------ 069 6.2 return ------------------------------------------------------------------------ 070 6.3 Standardwerte ------------------------------------------------------------------------ 070 Fals, muessen folgende Punkte gelten: - Der letzte Parameter muss einen Standardwert besitzen. - Zwischen zwei Parameter mit ... darf keiner ohne ... stehen. 071 6.4 Suffixr?ckgabetyp ------------------------------------------------------------------------ 072 6.5 Funktionsdeklaration ------------------------------------------------------------------------ 072 6.6 Module ------------------------------------------------------------------------ 074 6.7 Funktionen ?berladen ------------------------------------------------------------------------ 074 6.7.1 Unterscheidung in der Parameteranzahl ------------------------------------------------------------------------ 075 6.7.2 inline ------------------------------------------------------------------------ 076 6.7.3 Unterscheidung im Parametertyp ------------------------------------------------------------------------ 076 6.8 Lambda-Funktionen ------------------------------------------------------------------------ 079 6.9 Zusammenfassung ------------------------------------------------------------------------ 079 6.10 Spielprojekt ------------------------------------------------------------------------ 081 7 Klassen ------------------------------------------------------------------------ 081 7.1 Objektorientierte Programmierung ------------------------------------------------------------------------ 081 7.1.1 Objekte als abgrenzbare Einheiten ------------------------------------------------------------------------ 082 7.1.2 Nicht objektorientierte Objekte ------------------------------------------------------------------------ 083 7.2 Klassen als Bauplan ------------------------------------------------------------------------ 083 7.2.1 Definition ------------------------------------------------------------------------ 084 7.3 Zugriffsrechte ------------------------------------------------------------------------ 085 7.4 Konstruktoren ------------------------------------------------------------------------ 087 7.4.1 Standardkonstruktor ------------------------------------------------------------------------ 087 7.4.2 Der Destruktor ------------------------------------------------------------------------ 088 7.5 Methoden ------------------------------------------------------------------------ 089 7.5.1 Zugriffsmethoden ------------------------------------------------------------------------ 089 7.5.2 Konstante Methoden ------------------------------------------------------------------------ 090 7.6 Externe Definition ------------------------------------------------------------------------ 092 7.7 Mehrfachdefinition ------------------------------------------------------------------------ 093 7.8 Typalias ------------------------------------------------------------------------ 094 7.8.1 typedef ------------------------------------------------------------------------ 095 7.8.2 using ------------------------------------------------------------------------ 095 7.8.3 Zugriffsrecht ------------------------------------------------------------------------ 096 7.9 cv-Qualifizierung ------------------------------------------------------------------------ 097 7.10 Zusammenfassung ------------------------------------------------------------------------ 098 7.11 Spielprojekt ------------------------------------------------------------------------ 101 8 Arrays und Verweise ------------------------------------------------------------------------ 101 8.1 Arrays definieren ------------------------------------------------------------------------ 102 8.1.1! sizeof ------------------------------------------------------------------------ 102 8.2 Arbeiten mit Arrays ------------------------------------------------------------------------ 103 8.2.1 Initialisierung ------------------------------------------------------------------------ 103 8.2.2 Arrays durchlaufen ------------------------------------------------------------------------ 104 8.3 Arrays als Funktionsparameter I ------------------------------------------------------------------------ 105 8.4 Zeiger ------------------------------------------------------------------------ 105 8.4.1 Hexadezimalsystem ------------------------------------------------------------------------ 106 8.4.2 Der Adressoperator ------------------------------------------------------------------------ 107 8.4.3 Definition eines Zeigers ------------------------------------------------------------------------ 108 8.4.4 Dereferenzierung ------------------------------------------------------------------------ 108 8.4.5 Zeiger als Funktionsparameter ------------------------------------------------------------------------ 110 8.4.6 Zeiger auf Zeiger ------------------------------------------------------------------------ 111 8.4.7 Arrays als Funktionsparameter II ------------------------------------------------------------------------ 112 8.4.8 Zeigerarithmetik ------------------------------------------------------------------------ 113 8.5 Referenzen ------------------------------------------------------------------------ 115 8.6 Objekte als Funktionsparameter ------------------------------------------------------------------------ 115 8.6.1 Referenzen auf Objekte ------------------------------------------------------------------------ 116 8.6.2 Zeiger auf Objekte ------------------------------------------------------------------------ 117 8.6.3 Objekte als Methodenparameter ------------------------------------------------------------------------ 118 8.7 Zusammenfassung ------------------------------------------------------------------------ 118 8.8 Spielprojekt ------------------------------------------------------------------------ 119 9 Strings ------------------------------------------------------------------------ 119 9.1 char ------------------------------------------------------------------------ 120 9.1.1 cctype ------------------------------------------------------------------------ 121 9.2 C-Strings ------------------------------------------------------------------------ 123 9.2.1 cstring ------------------------------------------------------------------------ 123 strerror | Liefert die Textbeschreibung zu einer Fehlernummer. HSc: Zur Zeit bis zur 37sten. 123 9.2.2 Beispiel ------------------------------------------------------------------------ 123 Tab. 9-2 UEbersicht der cstring-Funktionen 124 9.3 Strings ------------------------------------------------------------------------ 125 9.3.1 Tastatureingabe von Strings ------------------------------------------------------------------------ 126 cin.ignore() = Ueberspringt das noch vorhandene Trennzeichen 126 9.3.2 Methoden von string ------------------------------------------------------------------------ HSc: Tabelle 9-3 (at(), front(), ...) mit den Methoden der String-Klasse, deren Namen und Erlaeuterungen. HSc: Der Ersatz fuer itoa ist to_string(Wert) fuer Ganzzahlige und Gleitkommatyp benutzbar. 127 Tab. 9-4 Umwandlungsfunktionen (stoi, stod, ...) fuer string Iteratormethoden (assign, append, begin, ...) 128 9.4 Zusammenfassung ------------------------------------------------------------------------ 128 9.5 Spielprojekt ------------------------------------------------------------------------ 131 10 Dynamische Speicherverwaltung ------------------------------------------------------------------------ 131 10.1 Zeiger ------------------------------------------------------------------------ 132 10.1.1 Zeiger und Konstanten ------------------------------------------------------------------------ 133 10.1.2 Zeiger auf Funktionen ------------------------------------------------------------------------ 134 10.1.3 Zeiger auf Klassenelemente ------------------------------------------------------------------------ 137 10.2 Referenzen ------------------------------------------------------------------------ 137 10.3 new und delete ------------------------------------------------------------------------ 139 10.3.1 Die Klasse Name ------------------------------------------------------------------------ 140 10.4 Smart Pointer ------------------------------------------------------------------------ 140 10.4.1 Unique Pointer ------------------------------------------------------------------------ 143 10.4.2 Shared Pointer ------------------------------------------------------------------------ 145 10.4.3 Weak Pointer ------------------------------------------------------------------------ 148 10.4.4 Smart Pointer und Arrays ------------------------------------------------------------------------ 148 10.4.5 Auto-Pointer ------------------------------------------------------------------------ 149 10.5 Zusammenfassung ------------------------------------------------------------------------ 149 10.6 Spielprojekt ------------------------------------------------------------------------ 151 11 Klassen-Vertiefung ------------------------------------------------------------------------ 151 11.1 Reihenfolge der Zugriffsrechte ------------------------------------------------------------------------ 153 11.2 Der this-Zeiger ------------------------------------------------------------------------ 154 11.3 Konstruktoren ------------------------------------------------------------------------ 156 11.3.1 Standardkonstruktor ------------------------------------------------------------------------ 157 11.3.2 Kopierkonstruktor ------------------------------------------------------------------------ 157 Wenn immer es moeglich ist, sollten als Zeiger oder Referenz uebergebenen Parameter konstant sein. 158 11.3.3 Die Klasse Name ------------------------------------------------------------------------ 159 flache ... tiefe Kopie 160 11.3.4 Elementinitialisierungsliste ------------------------------------------------------------------------ 163 11.3.5 Verschiebekonstruktor ------------------------------------------------------------------------ 166 11.3.6 Implizite Typumwandlung ------------------------------------------------------------------------ 166 11.3.7 Konstruktordelegation ------------------------------------------------------------------------ 167 11.4 Destruktoren ------------------------------------------------------------------------ 168 11.5 Konstante Objekte und Elemente ------------------------------------------------------------------------ 168 11.5.1 Implizite Objektparameter ------------------------------------------------------------------------ 170 11.5.2 mutable ------------------------------------------------------------------------ 176 11.6 Funktionen als deleted oder default definieren ------------------------------------------------------------------------ 177 11.7 Zusammenfassung ------------------------------------------------------------------------ 177 11.8 Spielprojekt ------------------------------------------------------------------------ 181 12 Klassen -Abschluss ------------------------------------------------------------------------ 181 12.1 Standardwerte f?r Attribute ------------------------------------------------------------------------ 181 12.2 Verschachtelte Klassendefinitionen ------------------------------------------------------------------------ 183 12.3 Statische Klassenelemente ------------------------------------------------------------------------ 183 12.3.1 Statische Methoden ------------------------------------------------------------------------ 186 12.3.2 Statische Attribute ------------------------------------------------------------------------ 191 12.3.3 Statische Variablen ------------------------------------------------------------------------ 192 12.4 Konstruktoren und ihre Anwendung ------------------------------------------------------------------------ 192 12.4.1 Funktionsaufruf aus Konstruktoren heraus ------------------------------------------------------------------------ 194 12.4.2 Unvollendet konstruierte Objekte ------------------------------------------------------------------------ 196 12.5 Implizite Klassenelemente ------------------------------------------------------------------------ 198 12.5.1 Impliziter Standardkonstruktor ------------------------------------------------------------------------ 198 12.5.2 Impliziter Kopierkonstruktor ------------------------------------------------------------------------ 199 : 12.5.3 Impliziter Verschiebekonstruktor ------------------------------------------------------------------------ 199 12.5.4 Impliziter Kopier-Zuweisungsoperator ------------------------------------------------------------------------ 200 12.5.5 Impliziter Verschiebe-Zuweisungsoperator ------------------------------------------------------------------------ 201 12.5.6 Impliziter Destruktor ------------------------------------------------------------------------ 201 Der implizite Destruktor (HSc: ~SimplerName() {}) ist public und inline. 201 12.6 Aufzaehlungen ------------------------------------------------------------------------ 201 HSc: enum eANT {FIRMA, ... short int iL=eANT.FIRMA 202 12.7 Zusammenfassung ------------------------------------------------------------------------ 203 12.8 Spielprojekt ------------------------------------------------------------------------ 205 13 Namensbereiche ------------------------------------------------------------------------ 205 13.1 Deklarative Bereiche, potenzielle und tatsaechliche Bezugsrahmen ------------------------------------------------------------------------ 208 13.2 Namensbereiche definieren ------------------------------------------------------------------------ 209 13.3 Die Using-Direktive ------------------------------------------------------------------------ 210 13.4 Ein Alias f?r Namensbereiche ------------------------------------------------------------------------ 211 13.5 Unbenannte Namensbereiche ------------------------------------------------------------------------ 211 13.6 Die Using-Deklaration ------------------------------------------------------------------------ 212 13.7 Zusammenfassung ------------------------------------------------------------------------ 213 13.8 Spielprojekt ------------------------------------------------------------------------ 215 14 Operatoren ?berladen ------------------------------------------------------------------------ 21 14.1 Zuweisungsoperatoren ------------------------------------------------------------------------ 215 14.1.1 Kopier-Zuweisungsoperator ------------------------------------------------------------------------ 21 14.1.2 Verschiebe-Zuweisungsoperator ------------------------------------------------------------------------ 218 14.1.3 Kombinierte Zuweisungsoperatoren ------------------------------------------------------------------------ 219 14.2 Rechenoperatoren ------------------------------------------------------------------------ 219 14.2.1 Operation als Methode ------------------------------------------------------------------------ 219 14.2.2 Operation als Funktion ------------------------------------------------------------------------ 222 14.2.3 Methode oder Funktion ------------------------------------------------------------------------ 223 14.2.4 Operatoren mit Verschiebe-Semantik ------------------------------------------------------------------------ 226 14.2.5 Standardverhalten nachbilden ------------------------------------------------------------------------ 228 14.3 Vergleichsoperatoren ------------------------------------------------------------------------ 229 14.3.1 Operator-Templates ------------------------------------------------------------------------ 229 14.4 Die Operatoren ? und ? ------------------------------------------------------------------------ 230 14.4.1 operator? ------------------------------------------------------------------------ 230 14.4.2 operator? ------------------------------------------------------------------------ 231 14.5 Der Operator [] ------------------------------------------------------------------------ 232 14.6 Der Operator() ------------------------------------------------------------------------ 233 14.7 Die Operatoren -> und ------------------------------------------------------------------------ 235 14.8 Umwandlungsoperatoren ------------------------------------------------------------------------ 236 14.9 Die Operatoren ++ und ------------------------------------------------------------------------ 238 14.9.1 Praefixoperatoren ------------------------------------------------------------------------ 238 14.9.2 Postfixoperatoren ------------------------------------------------------------------------ 239 14.9.3 Weitere Operatoren ------------------------------------------------------------------------ 240 14.10 Probleme mit Operatoren ------------------------------------------------------------------------ 241 14.11 Zusammenfassung ------------------------------------------------------------------------ 241 14.12 Spielprojekt ------------------------------------------------------------------------ 243 15 Templates ------------------------------------------------------------------------ 243 15.1 Klassen-Templates ------------------------------------------------------------------------ 245 15.2 Funktions-Templates ------------------------------------------------------------------------ 246 15.3 Template-Parameter ------------------------------------------------------------------------ 247 15.3.1 Standardargumente ------------------------------------------------------------------------ 247 15.4 Template-Spezialisierung ------------------------------------------------------------------------ 248 15.5 typename ------------------------------------------------------------------------ 249 15.6 Zusammenfassung ------------------------------------------------------------------------ 251 16 STL ------------------------------------------------------------------------ 251 16.1 Die Komponenten der STL ------------------------------------------------------------------------ 252 16.2 Container ------------------------------------------------------------------------ 252 16.2.1 Laufzeitklassen ------------------------------------------------------------------------ 253 16.2.2 Die Container im UEberblick ------------------------------------------------------------------------ 254 16.2.3 STL-konforme Container ------------------------------------------------------------------------ 255 16.3 Iteratoren ------------------------------------------------------------------------ 255 16.3.1 Entwurf eines Iterators ------------------------------------------------------------------------ 258 16.3.2 Ein Iterator fuer Name ------------------------------------------------------------------------ 260 16.3.3 Iteratorkategorien ------------------------------------------------------------------------ 263 16.3.4 STL-konforme Iteratoren erstellen ------------------------------------------------------------------------ 263 16.3.5 Iteratoren erzeugen ------------------------------------------------------------------------ 264 16.3.6 Insert-Iteratoren ------------------------------------------------------------------------ 267 16.3.7 Stream-Iteratoren ------------------------------------------------------------------------ 268 16.4 Algorithmen ------------------------------------------------------------------------ 268 16.4.1 Die Algorithmen im UEberblick ------------------------------------------------------------------------ 271 16.5 Die STL im Einsatz ------------------------------------------------------------------------ 271 16.5.1 Variable Funktionsaufrufe ------------------------------------------------------------------------ 275 16.5.2 Aufruf?bergreifende Zustaende ------------------------------------------------------------------------ 276 16.5.3 Element suchen ------------------------------------------------------------------------ 277 16.5.4 Element suchen mit eigener Bedingung ------------------------------------------------------------------------ 278 16.5.5 Elemente loeschen ------------------------------------------------------------------------ 278 16.5.6 Elemente kopieren ------------------------------------------------------------------------ ------------------------------------------------------------------------ 37001 ------------------------------------------------------------------------ 37366 ------------------------------------------------------------------------ 37731 ------------------------------------------------------------------------ 279 16.5.7 Elemente sortieren ------------------------------------------------------------------------ 281 16.5.8 Eigene Listeninitialisierungskonstruktoren ------------------------------------------------------------------------ 282 16.6 Zusammenfassung ------------------------------------------------------------------------ 282 16.7 Spielprojekt ------------------------------------------------------------------------ 287 17 Vererbung l , ------------------------------------------------------------------------ 287 17.1 Das Klassendiagramm der UME ------------------------------------------------------------------------ 290 17.2 Vererbung in C++ ------------------------------------------------------------------------ 292 17.3 Die Vererbungssyntax ------------------------------------------------------------------------ 296 17.4 Gesch?tzte Elemente ------------------------------------------------------------------------ 298 17.4.1 Zugriff auf Basisklassenelemente ------------------------------------------------------------------------ 298 17.5 Polymorphie ------------------------------------------------------------------------ 300 17.6 Verdecken von Methoden ------------------------------------------------------------------------ 302 17.7 UEberschreiben von Methoden ------------------------------------------------------------------------ 304 17.8 ' Virtuelle'Methoden ------------------------------------------------------------------------ 305 17.8.1 Virtuelle Methoden und Konstruktoren ------------------------------------------------------------------------ 307 17.8.2 Downcasts ------------------------------------------------------------------------ 308 17.8.3 Virtuelle Destruktoren ------------------------------------------------------------------------ 311 17.9 Rein-virtuelle Methoden ------------------------------------------------------------------------ 311 17.9.1 Rein-virtuelle Methodep mit Implementierung ------------------------------------------------------------------------ 312 17.9.2 Rein-virtuelle Destruktoren ------------------------------------------------------------------------ 313 17.10 Vererbung und Arrays ------------------------------------------------------------------------ 314 17.11 Vererbung und Standardwerte ------------------------------------------------------------------------ 315 17.12 Vererbung und ?berladene Operatoren ------------------------------------------------------------------------ 316 17.13 Versiegelte Elemente ------------------------------------------------------------------------ 316 17.13.1 Versiegelte Klasse ------------------------------------------------------------------------ 316 17.13.2 Versiegelte Methode ------------------------------------------------------------------------ 317 17.13.3 Warum Elemente versiegeln? ------------------------------------------------------------------------ 318 17.14 Geerbte Konstruktoren verwenden ------------------------------------------------------------------------ 319 17.15 UEberschreibungshilfe ------------------------------------------------------------------------ 320 17.16 Zusammenfassung ------------------------------------------------------------------------ 320 17.17 Spielprojekt ------------------------------------------------------------------------ 325 18 Vererbung II ------------------------------------------------------------------------ 325 18.1 Beziehungen ------------------------------------------------------------------------ 325 18.1.1 ist ein ------------------------------------------------------------------------ 330 18.1.2 ist implementiert mit ------------------------------------------------------------------------ 332 18.1.3 hat ein ------------------------------------------------------------------------ 333 18.2 Was wird vererbt? ------------------------------------------------------------------------ 333 18.2.1 Schnittstelle mit verbindlicher Implementierung ------------------------------------------------------------------------ 335 18.2.2 Schnittstelle mit ?berschreibbarer Implementierung ------------------------------------------------------------------------ 336 18.2.3 Schnittstelle ------------------------------------------------------------------------ 338 18.2.4 Implementierung ------------------------------------------------------------------------ 338 18.3 Das Offen-geschlossen-Prinzip ------------------------------------------------------------------------ 342 18.4 Operationen oben, Daten unten ------------------------------------------------------------------------ 344 18.5 Das Umkehrung-der-Abhaengigkeit-Prinzip ------------------------------------------------------------------------ 346 18.6 Das Einzelne-Verantwortung-Prinzip ------------------------------------------------------------------------ 347 18.7 Zusammenfassung ------------------------------------------------------------------------ 348 18.8 Spielprojekt ------------------------------------------------------------------------ 353 19 Mehrfachvererbung ------------------------------------------------------------------------ 354 19.1 Gemeinsame Basisklassen ------------------------------------------------------------------------ 356 19.2 Virtuelle Basisklassen ------------------------------------------------------------------------ 358 19.3 Konstruktoren virtueller Basisklassen ------------------------------------------------------------------------ 359 19.4 Einsatz_yon Mehrfachvererbung, ------------------------------------------------------------------------ 360 19.5 Zusammenfassung ------------------------------------------------------------------------ 361 19.6 Spielprojekt ------------------------------------------------------------------------ 365 20 Ausnahmen ------------------------------------------------------------------------ 365 20.1 Warum Ausnahmen? ,,,,,: ------------------------------------------------------------------------ 367 10.2 Einsatz von Ausnahmen ------------------------------------------------------------------------ 370 20.3 Vordefinierte Ausnahmen ------------------------------------------------------------------------ 371 20.3.1 Header-Datei ?exception? ------------------------------------------------------------------------ 371 20.3.2 Header-Datei ?typeinfo? ------------------------------------------------------------------------ 371 20.3.3 Header-Datei ?memory? ------------------------------------------------------------------------ 371 20.3.4 Header-Datei ?new? ------------------------------------------------------------------------ 372 20.3.5 Header-Datei ?stdexcept? ------------------------------------------------------------------------ 372 20.4 Ausnahmen im Detail ------------------------------------------------------------------------ 372 20.4.1 terminate ------------------------------------------------------------------------ 373 20.4.2 Das Verlassen eines Try-Blocks ------------------------------------------------------------------------ 374 20.4.3 uncaught_exception ------------------------------------------------------------------------ 374 20.4.4 Das Werfen einer Ausnahme ------------------------------------------------------------------------ 375 20.4.5 Das Fangen einer Ausnahme ------------------------------------------------------------------------ 378 20.5 Ausnahmespezifikationen ------------------------------------------------------------------------ 379 20.5.1 Ausnahmespezifikationen in der Praxis ------------------------------------------------------------------------ 379 20.6 Ausnahmen und Konstruktoren ------------------------------------------------------------------------ 381 20.7 Ausnahmen und Destruktoren ------------------------------------------------------------------------ 382 20.8 Ausnahmen und dynamische Speicherverwaltung ------------------------------------------------------------------------ 384 20.9 Ressourcenerwerb ist Initialisierung ------------------------------------------------------------------------ 385 20.10 Funktions-Try-Bloecke ------------------------------------------------------------------------ 387 20.11 Ausnahmensicherheit ------------------------------------------------------------------------ 387 20.12 Zusammenfassung ------------------------------------------------------------------------ 21 ------------------------------------------------------------------------ 21.1 21.2 21.3 21.4 ------------------------------------------------------------------------ Das Spiel ------------------------------------------------------------------------ 389 Aktionen ------------------------------------------------------------------------ 389 ------------------------------------------------------------------------ 392 Spielregeln ------------------------------------------------------------------------ 394 Raeume ------------------------------------------------------------------------ 396 Die Erzeugung der Spielwelt ------------------------------------------------------------------------ 396 21.4.1 Erstellen der Raeume ------------------------------------------------------------------------ 397 21.4.2 Erzeugen der Gegenstaende ------------------------------------------------------------------------ 398 21.4.3 Erstellen der Ausgaenge ------------------------------------------------------------------------ 399 2l A A Erzeugen von T?ren ------------------------------------------------------------------------ 402 21 .4.5 Erstellen der Interaktionen ------------------------------------------------------------------------ 405 407 Literatur Index ------------------------------------------------------------------------ ******* EOF ************************************************************