495.txt ************************************************************************ * Edit v1.033 from 2021-03-23 to 2023-09-01 by HSc+TSc * ************************************************************************ C++ fuer Dummies Davis, Stephan Randy WILEY-VCH Verlag, 6. vollstaendig ueberarbeitete Auflage 2012 ISBN: 978-3-527-70834-5 Seite Auszug ===== ================================================================ 019 Einfuehrung ------------------------------------------------------------------------ 019 Zu diesem Buch ------------------------------------------------------------------------ 019 UEber die CD ------------------------------------------------------------------------ 020 Was ist C++? ------------------------------------------------------------------------ 020 Konventionen in diesem Buch ------------------------------------------------------------------------ 021 Wie dieses Buch aufgebaut ist ------------------------------------------------------------------------ 021 Das ist noch nicht alles ------------------------------------------------------------------------ 022 Teil I: Einfuehrung in die C++-Programmierung ------------------------------------------------------------------------ 022 Teil II: Ein brauchbarer C++-Programmierer werden ------------------------------------------------------------------------ 022 Teil III: Eine Einfuehrung in Klassen ------------------------------------------------------------------------ 022 Teil IV: Vererbung ------------------------------------------------------------------------ 022 Teil V: Optionale Funktionen ------------------------------------------------------------------------ 023 Teil VI: Der Top-Ten-Teil ------------------------------------------------------------------------ 023 Icons in diesem Buch ------------------------------------------------------------------------ 023 Wie geht's weiter? ------------------------------------------------------------------------ 025 Teil I, Einfuehrung in die C++~Proqrammierung ------------------------------------------------------------------------ 025 Kapitel 1. Ihr erstes C++ - Progmmm ------------------------------------------------------------------------ 027 Was ist ein Programm? ------------------------------------------------------------------------ 028 Code::Blocks unter Windows installieren ------------------------------------------------------------------------ 031 Ihr erstes C++-Programm erstellen ------------------------------------------------------------------------ 032 Ein Projekt anlegen ------------------------------------------------------------------------ 033 Den C++-Code eingeben ------------------------------------------------------------------------ 035 Ihr Programm erstellen ------------------------------------------------------------------------ 036 Ihr Programm ausfuehren ------------------------------------------------------------------------ 037 Kommentierte Programme lesen ------------------------------------------------------------------------ 038 Das gemeinsame Geruest aller C++-Programme ------------------------------------------------------------------------ 038 Sourcecode durch Kommentare erlaeutern ------------------------------------------------------------------------ 039 Programme bestehen aus C++-Anweisungen ------------------------------------------------------------------------ 040 Deklarationen schreiben ------------------------------------------------------------------------ 041 Ausgabenerzeugen ------------------------------------------------------------------------ 041 Ausdruecke berechnen ------------------------------------------------------------------------ 041 Das Ergebnis eines Ausdrucks speichern ------------------------------------------------------------------------ 042 Den Rest des Programms untersuchen ------------------------------------------------------------------------ 043 Kapitel 2. ------------------------------------------------------------------------ 043 Variablen verwenden ------------------------------------------------------------------------ 043 Variablen deklarieren ------------------------------------------------------------------------ 044 Verschiedene Variablentypen fuer alle Faelle ------------------------------------------------------------------------ 045 UEberblick ueber die Einschraenkungen der Ganzzahlen in C++ ------------------------------------------------------------------------ 046 Rundungsprobleme loesen ------------------------------------------------------------------------ 047 Die Einschraenkungen von Flieszkommazahlen ------------------------------------------------------------------------ 048 Variablentypen deklarieren ------------------------------------------------------------------------ 050 Konstantentypen ------------------------------------------------------------------------ 051 Wertebereiche von numerischen Typen ------------------------------------------------------------------------ 052 Sonderzeichen ------------------------------------------------------------------------ 053 Reichen mit doppelter Spurbreite ------------------------------------------------------------------------ 054 Sind diese Berechnungen wirklich logisch? ------------------------------------------------------------------------ 054 Mixed-Mode-Ausdruecke ------------------------------------------------------------------------ 055 Automatische Deklarationen ------------------------------------------------------------------------ 057 Kapitel 3 ------------------------------------------------------------------------ 057 Mathematische Operationen ausfuehren ------------------------------------------------------------------------ 057 Einfache binaere Operationen ausfuehren ------------------------------------------------------------------------ 059 Ausdruecke zerlegen ------------------------------------------------------------------------ 059 Die Reihenfolge von Operationen bestimmen ------------------------------------------------------------------------ 060 Unaere Operationen ausfuehren ------------------------------------------------------------------------ 061 Mit Zuweisungsoperatoren arbeiten ------------------------------------------------------------------------ Kapitel 4 ------------------------------------------------------------------------ 063 Logische Operationen ausfuehren ------------------------------------------------------------------------ 063 Warum brauchen wir ueberhaupt logische Operationen? ------------------------------------------------------------------------ 064 Mit den einfachen logischen Operatoren arbeiten ------------------------------------------------------------------------ 064 Tabelle 4.1: Einfache logische Operatoren die die Alltagslogik repaesentieren. Operator ==, !=, <, >, &&, ||, ! 065 Logische Werte speichern ------------------------------------------------------------------------ 066 Mit logischen int-Variablen arbeiten ------------------------------------------------------------------------ 067 Vorsicht bei logischen Operationen mit Flieszkommavariablen ------------------------------------------------------------------------ 068 Binaerzahlen repraesentieren ------------------------------------------------------------------------ 069 Das dezimale Zahlensystem ------------------------------------------------------------------------ 069 Andere Zahlensysteme ------------------------------------------------------------------------ 069 Das binaere Zahlensystem ------------------------------------------------------------------------ 070 Bitweise logische Operationen ausfuehren ------------------------------------------------------------------------ 071 Tabelle 4.2: Bitweise Operatoren NOT ~, UND &, OR |, XOR ^ 071 Die bitweisen Operatoren ------------------------------------------------------------------------ 072 Die bitweisen Operatoren verwenden ------------------------------------------------------------------------ 073 Ein einfacher Test ------------------------------------------------------------------------ 075 Etwas Logisches mit logischen Berechnungen tun ------------------------------------------------------------------------ 077 Kapitel 5 ------------------------------------------------------------------------ 077 Den Proyrammabtauf steuern ------------------------------------------------------------------------ 077 Den Programmablauf mit Verzweigungsbefehlen steuern ------------------------------------------------------------------------ 079 Schleifen in einem Programm ausfuehren ------------------------------------------------------------------------ 080 Eine Schleife ausfuehren; waehrend eine Bedingung true ist ------------------------------------------------------------------------ 081 Die Autoinkrement-und Autodekrement-Funktionen verwenden ------------------------------------------------------------------------ 083 Mit der for-Schleife arbeiten ------------------------------------------------------------------------ 085 Die gefuerchtete Endlosschleife vermeiden ------------------------------------------------------------------------ 086 Potezielle Schleiferlkontrollen anwenden ------------------------------------------------------------------------ 089 Steuerbefehle verschachteln ------------------------------------------------------------------------ 091 Die Mehrwege-Verzweigung: switch ------------------------------------------------------------------------ Teil II ------------------------------------------------------------------------ 093 Ein brauchbarer C++~Proqrammierer werden ------------------------------------------------------------------------ 095 Kapitel 6 ------------------------------------------------------------------------ 095 Funktionen erstellen ------------------------------------------------------------------------ 095 Eine Funktion schreiben und verwenden ------------------------------------------------------------------------ 098 Unsere erste Funktion definieren ------------------------------------------------------------------------ 098 Die Funktion sumSequence() definiere ------------------------------------------------------------------------ 098 Die Funktion sumSequence() aufrufen ------------------------------------------------------------------------ 099 Teile und herrsche ------------------------------------------------------------------------ 099 Die Details von Funktionen verstehen ------------------------------------------------------------------------ 100 Einfache Funktionen verstehen ------------------------------------------------------------------------ 100 Funktionen mit Argumenten verstehen ------------------------------------------------------------------------ 104 Funktionsnamen ueberladen ------------------------------------------------------------------------ 105 Funktionsprototypen definieren ------------------------------------------------------------------------ 107 Variable Speichertypen ------------------------------------------------------------------------ 107 Variable golbal, static, local 109 Kapitel 7 ------------------------------------------------------------------------ 109 Sequenzen in Arrays speichern ------------------------------------------------------------------------ 109 Wozu werden Arrays benoetigt? ------------------------------------------------------------------------ 110 Ein Array verwenden ------------------------------------------------------------------------ 114 Ein Array initialisieren ------------------------------------------------------------------------ 115 Mit einem zu groszen Indexwert auf ein Array zugreifen ------------------------------------------------------------------------ 115 Mit Arrays arbeiten ------------------------------------------------------------------------ 115 Arrays von Arrays definieren und verwenden ------------------------------------------------------------------------ 116 Arrays von Zeichen verwenden ------------------------------------------------------------------------ 116 Ein Array von Zeichen erstellen ------------------------------------------------------------------------ 117 Einen String von Zeichen erstellen ------------------------------------------------------------------------ 119 Zeichenstrings manipulieren ------------------------------------------------------------------------ 121 Ein paar Bibliotheksfunktionen ------------------------------------------------------------------------ 122 Mehr Platz fuer Wide-Strings ------------------------------------------------------------------------ 123 Anzahl der Zeichen ... Kopiert ... Haengt an ... Findet das 1. Vorkommen ... Verleicht zwei ... 125 Kapitel 8 ------------------------------------------------------------------------ 125 Ein erster Blick auf C++ - Zeiqer ------------------------------------------------------------------------ 125 Eine Zeigervariable enthaelt die Adresse einer anderen Variable im Speicher. 125 Variablengroesze ------------------------------------------------------------------------ 127 Was ist in einer Adresse enthalten? ------------------------------------------------------------------------ 127 Der &-Operator sagt: Nenne mir deine Adresse. * ... Den Wert an folgender Adresse. HSc: Die Adresse ist immer gleich grosz. Zum Beispiel 4Byte. Der Abstand von Adresse zu Adresse nicht, da dort der Wert (int iWert: 4 Byte, double dWert: 12 Byte) steht. 127 Adressoperatoren ------------------------------------------------------------------------ 128 cout.self(ios::hex) 128 cout.unset(ios::dec) 129 Zeigervariablen verwenden ------------------------------------------------------------------------ 129 meinSohn=&VatersZimmer,; // Mein Sohn erfaehrt mein Zimmer-Nummer. Raum = *meinSohn // Mein Sohn gibt meine Zimmer-Nummer preis. HSc: "int* pI1, pI2" oder "int *pI1, *pI2"? 130 Verschiedene Typen von Zeigern verwenden ------------------------------------------------------------------------ 130 int* pnVari = nVari; *pnVari=10; 131 Zeiger an Funktionen uebergeben ------------------------------------------------------------------------ 131 UEbergabe als Wert ------------------------------------------------------------------------ 131 void fn(int nArg) { nArg=10; } void parent(void) { int n1=0; fn(n1); } // n1 hat an dieser Stellen den Wert 0. 132 Zeigerwert uebergeben ------------------------------------------------------------------------ 133 UEbergabe per Referenz ------------------------------------------------------------------------ 135 Konstante Irritationen ------------------------------------------------------------------------ 135 Einen Speicherblock namens Heap nutzen ------------------------------------------------------------------------ 135 Begrenzter Gueltigkeitsbereich ------------------------------------------------------------------------ 137 Das Problem des Gueltigkeitsbereichs untersuchen ------------------------------------------------------------------------ 137 Mit Hilfe des Heaps eine Loesung finden ------------------------------------------------------------------------ 137 ... Speicherblock der von dem Programmierer kontrolliert wird. Dann kann er den Speicher reservieren und wieder freigeben, wenn er das will. ... Ein solcher Speicherblock wird als Heap bezeichnet. HSc: fload *pfZ = new fload; // Zeiger auf eine Fload-Zahl auf dem reservierten Speicherbereich auf dem HEEP! ... // Kann dazwischen eine Funktion mit RETURN verlassen worden sein? Eigendlich JA! delete pfZ; // Heapspeicher von Groesze fload worauf den Zeiger zeigt freigeben. pfZ=0; // Eine nicht notwendige Vorsichtsmasznahme. 139 Kapitel 9. ------------------------------------------------------------------------ 139 Ein zweiter Blick auf C++-Zeiyer ------------------------------------------------------------------------ 139 Operationen fuer Zeigervariablen definieren ------------------------------------------------------------------------ 140 Arrays im Licht von Zeigervariablen noch einmal betrachten Operatoren auf die Adresse eines Arrays anwenden ------------------------------------------------------------------------ 143 Zeigeroperationen auf einen String ausdehnen ------------------------------------------------------------------------ 144 Gruende fuer die zeigerbasierte String-Manipulation ------------------------------------------------------------------------ 145 Operatoren auf andere Zeigertypen als char anwenden ------------------------------------------------------------------------ 145 Einen Zeiger mit einem Array vergleichen ------------------------------------------------------------------------ 148 Wann gibt's einen Zeiger nicht? ------------------------------------------------------------------------ 149 Arrays von Zeigern deklarieren und verwenden ------------------------------------------------------------------------ 150 Arrays von Zeichenstrings nutzen ------------------------------------------------------------------------ 151 Auf die Argumente von main() zugreifen ------------------------------------------------------------------------ 153 Die Wildcard-Erweiterung wird auch unter allen Versionen von Unix und Linux vorgenommen. Unter aelteren Versionen von gcc wurde die Wildcard-Erweiterung nicht ausgefuehrt, und unter Visual C++ Express wird sie ebenfalls nicht ausgefuehrt. 155 Kapitel 10. ------------------------------------------------------------------------ 155 Der C++*Praeprozessor ------------------------------------------------------------------------ 155 Was ist ein Praeprozessor? ------------------------------------------------------------------------ 156 Einbinden von Dateien ------------------------------------------------------------------------ 159 Die Definition von Dingen ------------------------------------------------------------------------ 161 Und wenn ich nichts definieren will? ------------------------------------------------------------------------ 162 Ein paar Alternativen aufzaehlen ------------------------------------------------------------------------ 163 Dinge mit einem >>ja aber<< einbinden ------------------------------------------------------------------------ 164 Vordefinierte Objekte ------------------------------------------------------------------------ 167 Typendefinitionen mit typedef ------------------------------------------------------------------------ 167 typedef 169 Teil ll. ------------------------------------------------------------------------ 169 Eine Einfuehrung in Klassen i ------------------------------------------------------------------------ 171 Kapitel 11 ------------------------------------------------------------------------ 171 Ein Blick auf die objektorientierte Programmierung ------------------------------------------------------------------------ 171 Die Abstraktion und der Mikrowellenherd ------------------------------------------------------------------------ 172 Nachos prozedural zubereiten ------------------------------------------------------------------------ 172 Nachos objektorientiert zubereiten ------------------------------------------------------------------------ 173 Klassenbildung und Mikrowellen ------------------------------------------------------------------------ 174 Wozu Klassen bilden? ------------------------------------------------------------------------ 175 Kapitel 12 ------------------------------------------------------------------------ 175 Klassen in C++ ------------------------------------------------------------------------ 175 Einfuehrung der Klasse ------------------------------------------------------------------------ 175 Das Format einer Klasse ------------------------------------------------------------------------ 176 Auf die Elemente einer Klasse zugreifen ------------------------------------------------------------------------ TSc: struct = class publich 177 Objekte aktivieren ------------------------------------------------------------------------ 177 Reale Objekte simulieren ------------------------------------------------------------------------ 178 Wozu dienen Elementfunktionen? ------------------------------------------------------------------------ 178 OO-Regelen Einen Objektzeiger dereferenzieren 179 Eine Elementfunktion hinzufuegen ------------------------------------------------------------------------ 180 Eine Elementfunktion aufrufen ------------------------------------------------------------------------ 182 Von einer Elementfunktion auf andere Elemente zugreifen ------------------------------------------------------------------------ 183 Aufloesung des Gueltigkeitsbereichs ------------------------------------------------------------------------ 184 Eine Elementfunktion in der Klasse definieren ------------------------------------------------------------------------ HSc: Eine Klasse mit Elementfunktionen in einer Header-Datei definieren. ... in der Incluse-Datei Saving.h aus 186 Elementfunktionen separat definieren ------------------------------------------------------------------------ 186 Objekt Elementfunktionen inline (klein) oder outline (grosz). 188 Elementfunktionen ueberladen ------------------------------------------------------------------------ 191 Kapitel 13 ------------------------------------------------------------------------ 191 Objekte mit Zeigern manipulieren ------------------------------------------------------------------------ 191 Arrays aus Objekten deklarieren ------------------------------------------------------------------------ 192 Zeiger auf Objekte deklarieren ------------------------------------------------------------------------ 192 s.gpa <-> student s Student *pS; pS=&s; 193 Einen Objektzeiger dereferenzieren ------------------------------------------------------------------------ 193 *pS.gpa // Einen Fehler Punkt kommt vor * -> (*pS).gpa // Richtig! oder pS->gpa 194 Der Pfeiloperator Objekte an Funktionen uebergeben ------------------------------------------------------------------------ 194 Eine Funktion mit einem Objektwert aufrufen ------------------------------------------------------------------------ 196 Eine Funktion mit einem Objektzeiger aufrufen ------------------------------------------------------------------------ 197 Eine Funktion mit dem Referenzoperator aufrufen ------------------------------------------------------------------------ 197 Student s; someFn(&s); <- void someFn(Student* pS); someFn(s); <- void someFn(Student& refS); 199 Wozu Zeiger oder Referenzen? Zurueck zum Heap ------------------------------------------------------------------------ 200 Viele Objekte auf dem Heap anlegen ------------------------------------------------------------------------ 201 Zeiger und Referenzen vergleichen ------------------------------------------------------------------------ 201 Verknuepfungen mit verketteten Listen erstellen ------------------------------------------------------------------------ 201 Einfach verkettet. 202 Andere Operationen auf eine verkettete Liste anwenden ------------------------------------------------------------------------ 203 Das Linked ListData-Beispielprogramm ------------------------------------------------------------------------ 207 Ein Hoffnungsstrahl: Eine Liste von Containern, die mit der C++-Library verknuepft sind ------------------------------------------------------------------------ 209 Kapitel 14 ------------------------------------------------------------------------ 209 Nicht stoeren: Elemente schuetzen ------------------------------------------------------------------------ 209 Elemente schuetzen ------------------------------------------------------------------------ 209 Wozu benoetigen Sie geschuetzte Elemente? ------------------------------------------------------------------------ 210 Wie geschuetzte Elemente funktionieren ------------------------------------------------------------------------ 210 protectet privat -> Kap. 19 public: Nicht Elementfunktionen koennen darauf zugreifen. protected: ... nicht darauf zugreifen. privat Funktionalitaeten nach auszen hin nicht bekannt sein muss. HSc: Funktionalitaeten auf die der Programmierer zugreifen oder aendern muss, wenn er die Funktionalitaet der Klasse erweitern moechte. -> protected? Funktionlitaeten der Klasse gemaesz vererbungskonzept. Private sichtbar. Mitgleider koennen inerhalb von Klassen auf private Mitgleider zugreifen. 211 Argumente fuer den Einsatz geschuetzter Elemente ------------------------------------------------------------------------ 211 Den internen Status einer Klasse schuetzen ------------------------------------------------------------------------ 212 Eine Klasse mit eingeschraenkter Schnittstelle verwenden ------------------------------------------------------------------------ 213 Nicht-Elementfunktionen Zugriff auf geschuetzte Elemente geben ------------------------------------------------------------------------ 217 Kapitel 15 ------------------------------------------------------------------------ 217 Objekte konstruieren und zerstoeren ------------------------------------------------------------------------ 217 Objekte erstellen ------------------------------------------------------------------------ 218 Konstruktoren verwenden ------------------------------------------------------------------------ 218 Ein einzelnes Objekt konstruieren ------------------------------------------------------------------------ 220 Mehrere Objekte konstruieren ------------------------------------------------------------------------ 221 Ein Duplex konstruieren ------------------------------------------------------------------------ 223 Einen Destruktor analysieren ------------------------------------------------------------------------ 223 Warum Sie den Destruktor benoetigen ------------------------------------------------------------------------ 223 Mit Destruktoren arbeiten ------------------------------------------------------------------------ 229 Kapitel 16 ------------------------------------------------------------------------ 229 Konstuktoren mit Argumenten ------------------------------------------------------------------------ 229 Konstruktoren mit Argumenten ausstatten ------------------------------------------------------------------------ 230 Einen Konstruktor verwenden ------------------------------------------------------------------------ 232 Konstruktoren ueberladen ------------------------------------------------------------------------ 234 Standardmaeszige Standardkonstruktoren ------------------------------------------------------------------------ 236 Klassenelemente konstruieren ------------------------------------------------------------------------ 236 Ein komplexes Datenelement konstruieren ------------------------------------------------------------------------ 241 Ein konstantes Datenelement konstruieren ------------------------------------------------------------------------ 241 Die Reihenfolge der Konstruktion ------------------------------------------------------------------------ 241 const 242 Lokale Objekte werden der Reihenfolge nach konstruiert ------------------------------------------------------------------------ 242 Statische Objekte werden nur einmal konstruiert ------------------------------------------------------------------------ 243 Alle globalen Objekte werden vor main() konstruiert ------------------------------------------------------------------------ 243 Globale Objekte werden in keiner bestimmten Reihenfolge konstruiert ------------------------------------------------------------------------ 245 Elemente werden in der Reihenfolge konstruiert, in der sie deklariert werden ------------------------------------------------------------------------ 245 Destruktoren werden in der umgekehrten Reihenfolge der Konstruktoren aufgerufen ------------------------------------------------------------------------ 245 Konstruktoren als Form der Konvertierung ------------------------------------------------------------------------ 246 Explicit, unterwuenschte Konvertierungsmoeglichkeiten ausschlieszen. 247 Kapitel 17 ------------------------------------------------------------------------ 247 Der Copy-Konstruktor ------------------------------------------------------------------------ 247 Ein Objekt kopieren ------------------------------------------------------------------------ 247 Warum Sie Copy-Konstruktoren brauchen ------------------------------------------------------------------------ 248 Die Copy-Konstruktoren verwenden ------------------------------------------------------------------------ 250 Der automatische Copy-Konstruktor ------------------------------------------------------------------------ 252 Flache oder tiefe Kopien erstellen ------------------------------------------------------------------------ 256 Temporaere Objekte ------------------------------------------------------------------------ 258 Temporaere Objekte dauerhaft vermeiden ------------------------------------------------------------------------ 259 Kapitel 18 ------------------------------------------------------------------------ 259 Statische Elemente ------------------------------------------------------------------------ 259 Ein statisches Element definieren ------------------------------------------------------------------------ 259 Warum Sie statische Elemente benoetigen ------------------------------------------------------------------------ 260 Statische Elemente verwenden ------------------------------------------------------------------------ 260 static HSc: Das Datenelement "static..." ist Teil der Klasse, vererbt, aber gehoert nicht zu den abgeleiteten Klassen. Alle abgeleiteten Klassen koennen es verwenden wie eine globale Element in C. 161 Direkt den Klassennamen 261 Statische Datenelemente referenzieren ------------------------------------------------------------------------ 262 Verwendungsmoeglichkeiten statischer Datenelemente ------------------------------------------------------------------------ 263 Statische Elementfunktionen deklarieren ------------------------------------------------------------------------ 265 Was ist ueberhaupt this? ------------------------------------------------------------------------ 267 Teil IV ------------------------------------------------------------------------ 267 Vererbung ------------------------------------------------------------------------ 269 Kapitel 19 ------------------------------------------------------------------------ 269 Eine Klasse erben ------------------------------------------------------------------------ 270 Brauche ich Vererbung? ------------------------------------------------------------------------ 271 Wie funktioniert die Vererbung einer Klasse? ------------------------------------------------------------------------ 273 Eine Unterklasse verwenden ------------------------------------------------------------------------ 273 Eine Unterklasse konstruieren ------------------------------------------------------------------------ 275 Eine Unterklasse zerstoeren ------------------------------------------------------------------------ 275 Die HAS_A-Beziehung ------------------------------------------------------------------------ 277 Kapitel 20 ------------------------------------------------------------------------ 277 Virtuelle Elementfunktionen ------------------------------------------------------------------------ 280 Warum Sie Polymorphismus brauchen ------------------------------------------------------------------------ 280 Wie funktioniert Polymorphismus? ------------------------------------------------------------------------ 282 Wann ist eine Funktion virtuell und wann nicht? ------------------------------------------------------------------------ 283 Virtuelle Betrachtungen ------------------------------------------------------------------------ 285 Kapitel 21 ------------------------------------------------------------------------ 285 Klassen faktorisieren ------------------------------------------------------------------------ 285 Das Faktorisieren ------------------------------------------------------------------------ 289 Abstrakte Klassen implementieren ------------------------------------------------------------------------ 290 Das Konzept der abstrakten Klasse ^ ------------------------------------------------------------------------ 292 Wie man aus einer abstrakten Klasse eine wirkliche Klasse macht ------------------------------------------------------------------------ 292 Abstrakte Klassen uebergeben ------------------------------------------------------------------------ 293 Teil V ------------------------------------------------------------------------ 293 Optionale Funktionen ------------------------------------------------------------------------ 295 Kapitel 22 ------------------------------------------------------------------------ 295 Ein neuer Zuweisungsoperator ------------------------------------------------------------------------ 295 Operatoren mit Funktionen vergleichen ------------------------------------------------------------------------ 296 Einen neuen Operator einfuegen ------------------------------------------------------------------------ 296 Flache Kopien zu erstellen ist ein tiefes Problem ------------------------------------------------------------------------ 298 Den Zuweisungsoperator ueberladen ------------------------------------------------------------------------ 303 Den Indexoperator ueberladen ------------------------------------------------------------------------ 305 Kapitel 23 ------------------------------------------------------------------------ 305 Mit Stream-l/0 arbeiten ------------------------------------------------------------------------ 305 Wie funktioniert Stream-I/0? ------------------------------------------------------------------------ 306 Default Stream-Objekte ------------------------------------------------------------------------ 307 Die fstream-Unterklassen ------------------------------------------------------------------------ 307 fstream Tabelle 23.2 Konstanten zur Steuerung der OEffnung von Dateien 308 Vielfaeltiges OEffnen ------------------------------------------------------------------------ HSc: ios_base::binary wandelt NICHT automatisch den Zeilenumbruch in die Art und Weise wie es das Betriebssystem verwendet. 309 Datei, was machst Du gerade? ------------------------------------------------------------------------ 309 Kann ich ein Beispiel sehen? ------------------------------------------------------------------------ 310 ifstream* pFileStream=0; HSc: ifstream pFileStream=new ifstream(pcaName); cerr << nicht geoeffnet werden delete pFile Stream NEIN zuvor war ein break; 313 Andere Methoden der Stream-Klassen ------------------------------------------------------------------------ 314 Tabelle 23.3 Funktionen von fstream-Klassen 314 Streams direkt lesen und schreiben ------------------------------------------------------------------------ 314 write + read 315 ios.base::in|ios.base:binary FileCopy C++ 316 Das Format kontrollieren ------------------------------------------------------------------------ 316 Tabelle 23.4 Formatanweisungen 318 Was ist mit endl? ------------------------------------------------------------------------ 318 Positionierung des Zeigers innerhalb einer Datei ------------------------------------------------------------------------ 319 Die stringstream-Unterklassen verwenden ------------------------------------------------------------------------ 322 Manipulatoren manipulieren ------------------------------------------------------------------------ 326 Kapitel 24 ------------------------------------------------------------------------ 325 Fehler Verarbeiten - Ausnahmen ------------------------------------------------------------------------ 327 Warum brauche ich einen neuen Fehlermechanismus? ------------------------------------------------------------------------ 328 Den Ausnahmemechanismus untersuchen ------------------------------------------------------------------------ 331 Welche Dinge sind >>throw<<-faehig? ------------------------------------------------------------------------ 334 Einfach mal durchreichen ------------------------------------------------------------------------ 337 Kapitel 25 ------------------------------------------------------------------------ 337 Mehrfachtvererbung ------------------------------------------------------------------------ 337 Wie funktioniert die Mehrfachvererbung? ------------------------------------------------------------------------ 339 Vererbungsmehrdeutigkeiten beseitigen ------------------------------------------------------------------------ 340 Virtuelle Vererbung hinzufuegen ------------------------------------------------------------------------ 341 Objekte der Mehrfachvererbung erzeugen ------------------------------------------------------------------------ 347 Eine gegenteilige Meinung ------------------------------------------------------------------------ 349 Kapitel 26 ------------------------------------------------------------------------ 349 C++-Templates durchleuchten ------------------------------------------------------------------------ 350 Eine Funktion in einem Template verallgemeinern ------------------------------------------------------------------------ 352 Template-Klassen ------------------------------------------------------------------------ 356 Tipps fuer die Verwendung von Templates ------------------------------------------------------------------------ 357 Kapitel 27 ------------------------------------------------------------------------ 357 Standard Template Library als Standard Verwenden ------------------------------------------------------------------------ 358 Der string-Container ------------------------------------------------------------------------ 362 Die list-Container ------------------------------------------------------------------------ 363 Listen durchwandern ------------------------------------------------------------------------ 364 Operationen auf ganzen Listen ------------------------------------------------------------------------ 365 Beispiel, bitte! ------------------------------------------------------------------------ 309 Teil VI ------------------------------------------------------------------------ 309 Der Top-Ten-Teil ------------------------------------------------------------------------ 371 Kapitel 28 ------------------------------------------------------------------------ 371 Zehn Methoden, um Fehler in einem Programm zu vermeiden ------------------------------------------------------------------------ 371 Aktivieren Sie alle Warnungen und Fehlermeldungen ------------------------------------------------------------------------ 372 Pflegen Sie einen sauberen und konsistenten Programmierstil ------------------------------------------------------------------------ 372 Schraenken Sie die Sichtbarkeitsbereiche ein ------------------------------------------------------------------------ 374 Kommentieren Sie Ihren Code ------------------------------------------------------------------------ 374 Durchlaufen Sie jeden Pfad mindestens einmal im Einzelschrittmodus ------------------------------------------------------------------------ 374 Vermeiden Sie es, Operatoren zu ueberladen ------------------------------------------------------------------------ 375 Mit dem Heap arbeiten ------------------------------------------------------------------------ 375 Fehler mit Ausnahmen behandeln ------------------------------------------------------------------------ 375 Deklarieren Sie Destruktoren virtuell ------------------------------------------------------------------------ 377 Vermeiden Sie die Mehrfachvererbung ------------------------------------------------------------------------ ------------------------------------------------------------------------ 379 Kapitel 29 ------------------------------------------------------------------------ 379 (Fast) Zehn Websites zu alten fragen mnd um C++ ------------------------------------------------------------------------ 379 C-plusplus.de (deutsch) ------------------------------------------------------------------------ 379 Cplusplus.com (englisch) ------------------------------------------------------------------------ 379 Code-Blocks ------------------------------------------------------------------------ 380 Visual C++ Express Edition ------------------------------------------------------------------------ 380 Forum zur Visual C++ Express Edition ------------------------------------------------------------------------ 380 Referenz zur Windows-Programmierung mit C++ ------------------------------------------------------------------------ 380 Referenz zu C (englisch) ------------------------------------------------------------------------ 380 Referenz zu C (deutsch) ------------------------------------------------------------------------ 380 Informationen zu C++11 ------------------------------------------------------------------------ 381 Anhang A ------------------------------------------------------------------------ 381 UEber die CD ------------------------------------------------------------------------ 381 Systemanforderungen ------------------------------------------------------------------------ 381 Die CD benutzen ------------------------------------------------------------------------ 382 Der Inhalt der CD ' ------------------------------------------------------------------------ 382 Entwicklungswerkzeug ------------------------------------------------------------------------ 382 Programm-Quellcode ------------------------------------------------------------------------ 382 Falls Sie Probleme mit der CD haben ------------------------------------------------------------------------ 305 Stichwortverzeichnis ------------------------------------------------------------------------ ******* EOF ************************************************************