494.txt ************************************************************************* * Edit v1.010 from 2021-05-19 to 2023-04-18 by JPe+HSc * ************************************************************************* C++ Lernen und professionell anwenden Peter Prinz, Ulla Kirch-Prinz MITP Verlag 1999, ISBN: 3-8266-0423-7 Seite Auszug ======================================================================== 019 Einleitung ------------------------------------------------------------------------ 021 Grundlagen ------------------------------------------------------------------------ 022 Entwicklung und Eigenschaften von C++ ------------------------------------------------------------------------- 024 Objektorientierte Programmierung ------------------------------------------------------------------------ 026 Erstellen eines C++ - Programms ------------------------------------------------------------------------ 028 Ein erstes C++ - Programm ------------------------------------------------------------------------ 030 Struktur einfacher C++ - Programme ------------------------------------------------------------------------ 032 UEbungen ------------------------------------------------------------------------ 034 Loesungen ------------------------------------------------------------------------ 035 Elementare Datenypen, Konstanten und Variablen ------------------------------------------------------------------------ 036 Elementare Datentypen ------------------------------------------------------------------------ 042 Konstanten ------------------------------------------------------------------------ 046 Escape-Sequenzen ------------------------------------------------------------------------ 048 Namen ------------------------------------------------------------------------ 050 Variablen ------------------------------------------------------------------------ 052 Die Schluesselworte const und volatile ------------------------------------------------------------------------ 054 UEbungen ------------------------------------------------------------------------ 056 Loesungen ------------------------------------------------------------------------ 059 Verwenden von Funktionen und Klassen ------------------------------------------------------------------------ 060 Deklaration von Funktionen ------------------------------------------------------------------------ 062 Aufruf von Funktionen ------------------------------------------------------------------------ 064 Der Typ void fuer Funktionen ------------------------------------------------------------------------ 066 Header-Dateien ------------------------------------------------------------------------ 068 Standard-Header-Dateien ------------------------------------------------------------------------ 070 Verwenden von Standardklassen ------------------------------------------------------------------------ 072 UEbungen ------------------------------------------------------------------------ 074 Loesungen ------------------------------------------------------------------------ 077 4 Ein- und Ausgaben mit Streams ------------------------------------------------------------------------ 077 Streams ------------------------------------------------------------------------ 078 Formatierung und Manipulatoren ------------------------------------------------------------------------ 080 Formatierte Ausgabe von Ganzzahlen ------------------------------------------------------------------------ 082 Formatierte Ausgabe von Gleitpunktzahlen ------------------------------------------------------------------------ 084 Ausgabe in Felder ------------------------------------------------------------------------ 086 Ausgabe von Zeichen Strings und booleschen Werten ------------------------------------------------------------------------ 090 Formatierte Eingabe ------------------------------------------------------------------------ 092 Formatierte Eingabe von Zahlen ------------------------------------------------------------------------ 094 Unformatierte Ein- /Ausgabe ------------------------------------------------------------------------ 096 UEbungen ------------------------------------------------------------------------ 098 Loesungen ------------------------------------------------------------------------ 101 5 Operatoren fuer elementare Datentypen ------------------------------------------------------------------------ 102 Bindre arithmetische Operatoren ------------------------------------------------------------------------ 104 Undre arithmetische Operatoren ------------------------------------------------------------------------ 106 Zuweisungen ------------------------------------------------------------------------ 108 Vergleichsoperatoren ------------------------------------------------------------------------ 110 Logische Operatoren ------------------------------------------------------------------------ 110 || -> logisches ODER, && -> logisches UND, ! -> logisches NOT HSc | -> binaeres ODER, & -> binaeres UND, ~ -> binaeres NOT TEE.CPP ios::openmode iosLogBuch = ios_base::out | ios_base::app;; ... iosLogBuch=iosLogBuch & ~ios_base::app; 112 UEbungen ------------------------------------------------------------------------ 114 Loesungen ------------------------------------------------------------------------ 115 6 Kontrollstrukturen ------------------------------------------------------------------------ 116 Die while-Schleife ------------------------------------------------------------------------ 118 Die for-Schleife ------------------------------------------------------------------------ 122 Die do-while-Schleife ------------------------------------------------------------------------ 124 Verzweigungen mit if-else ------------------------------------------------------------------------ 126 else-if-Ketten ------------------------------------------------------------------------ 128 Bedingte Bewertung ------------------------------------------------------------------------ 130 Auswahl mit switch ------------------------------------------------------------------------ 132 Spr|nge mit break, continue und goto ------------------------------------------------------------------------ 134 UEbungen ------------------------------------------------------------------------ 136 Loesungen ------------------------------------------------------------------------ 139 7 Symbolische Konstanten und Makros ------------------------------------------------------------------------ 140 Makros ------------------------------------------------------------------------ 142 Makros mit Parametern ------------------------------------------------------------------------ 144 Arbeiten mit der #define-Direktive ------------------------------------------------------------------------ 146 Bedingte Kompilierung ------------------------------------------------------------------------ 148 Standardmakros zur Behandlung von Zeichen ------------------------------------------------------------------------ 148 Dateiende + oder Unix + 150 Umlenken von Standardeingabe und -ausgdbe ------------------------------------------------------------------------ 152 UEbungen ------------------------------------------------------------------------ 152 Filterprogramme Zeilen exe <(1.) test.dat (2.)> test.neu HSc: Was wird zu 1. gemacht und was zu 2., siehe oben in Klammern. 154 Loesungen ------------------------------------------------------------------------ 159 8 Umwandlung arithmetischer Datentypen ------------------------------------------------------------------------ 160 Implizite Typumwandlungen ------------------------------------------------------------------------ 162 Verfahren bei arithmetischen Typumwandlungen ------------------------------------------------------------------------ 164 Implizite Typumwandlungen bei Zuweisungen ------------------------------------------------------------------------ 166 Weitere Typumwandlungen ------------------------------------------------------------------------ 168 UEbungen ------------------------------------------------------------------------ 170 Loesungen ------------------------------------------------------------------------ 173 9 Die Standardklasse string ------------------------------------------------------------------------ 174 Definition und Zuweisung von Strings ------------------------------------------------------------------------ 176 Verketten von Strings ------------------------------------------------------------------------ 178 Strings vergleichen ------------------------------------------------------------------------ 180 Einf|gen und Lvschen in Strings ------------------------------------------------------------------------ 182 Suchen und Ersetzen in Strings ------------------------------------------------------------------------ 184 Zugriff auf Zeichen in Strings ------------------------------------------------------------------------ 186 UEbungen ------------------------------------------------------------------------ 187 time(); ctime 188 Loesungen ------------------------------------------------------------------------ 191 10 Funktionen ------------------------------------------------------------------------ 192 Bedeutung von Funktionen in C++ ------------------------------------------------------------------------ 194 Erstellen eigener Funktionen ------------------------------------------------------------------------ 196 Return-Wert von Funktionen ------------------------------------------------------------------------ 198 UEbergabe von Argumenten ------------------------------------------------------------------------ 200 inline-Funktionen ------------------------------------------------------------------------ 202 Default-Argumente ------------------------------------------------------------------------ 204 UEberladen von Funktionen ------------------------------------------------------------------------ 206 Rekursive Funktionen ------------------------------------------------------------------------ 208 UEbungen ------------------------------------------------------------------------ 211 Loesungen ------------------------------------------------------------------------ 217 11 Speicherklassen und Namensbereiche ------------------------------------------------------------------------ 218 Speicherklasse von Objekten ------------------------------------------------------------------------ 220 Die Speicherklasse extern ------------------------------------------------------------------------ 222 Die Speicherklasse static ------------------------------------------------------------------------ 224 Die Speicherklassen auto und register ------------------------------------------------------------------------ 226 Speicherklassen von Funktionen ------------------------------------------------------------------------ 228 Namensbereiche ------------------------------------------------------------------------ 230 Das Schl|sselwort using ------------------------------------------------------------------------ 232 UEbungen ------------------------------------------------------------------------ 236 Loesungen ------------------------------------------------------------------------ 241 12 Referenzen und Zeiger ------------------------------------------------------------------------ 242 Definition von Referenzen ------------------------------------------------------------------------ 244 Referenzen als Parameter ------------------------------------------------------------------------ 246 Referenzen als Return-Wert ------------------------------------------------------------------------ 248 Ausdr|cke mit Referenztyp ------------------------------------------------------------------------ 250 Definition von Zeigern ------------------------------------------------------------------------ 252 Der Verweisoperator ------------------------------------------------------------------------ 254 Zeiger als Parameter ------------------------------------------------------------------------ 256 UEbungen ------------------------------------------------------------------------ 258 Loesungen ------------------------------------------------------------------------ 263 13 Definition von Klassen ------------------------------------------------------------------------ 264 Klassen-Konzept ------------------------------------------------------------------------ 266 Definition von Klassen ------------------------------------------------------------------------ 267 Die Marken private: und public: kvnnen innerhalb einer Klasse beliebig ... ------------------------------------------------------------------------ 268 Definition von Methoden ------------------------------------------------------------------------ 270 Definition von Objekten ------------------------------------------------------------------------ 272 Verwendung von Objekten ------------------------------------------------------------------------ 274 Zeiger auf Objekte ------------------------------------------------------------------------ 276 Structs ------------------------------------------------------------------------ 278 Unions ------------------------------------------------------------------------ 280 UEbungen ------------------------------------------------------------------------ 282 Loesung ------------------------------------------------------------------------ 285 14 Methoden ------------------------------------------------------------------------ 286 Konstruktoren ------------------------------------------------------------------------ 288 Aufruf von Konstruktoren ------------------------------------------------------------------------ 290 Destruktoren ------------------------------------------------------------------------ 292 Inline-Methoden r.. ------------------------------------------------------------------------ 294 Zugriffsmethoden ------------------------------------------------------------------------ 296 const-Objekte und -Methoden ------------------------------------------------------------------------ 298 Standardmethoden ------------------------------------------------------------------------ 300 Der this-Zeiger ------------------------------------------------------------------------ 302 UEbergabe von Objekten ------------------------------------------------------------------------ 304 Objekte als Return-Wert : ------------------------------------------------------------------------ 306 UEbungen ------------------------------------------------------------------------ 310 Loesungen ------------------------------------------------------------------------ 317 15 Teilobjekte und statische Elemente ------------------------------------------------------------------------ 318 Klassen mit Teilobjekten ------------------------------------------------------------------------ 320 Elementinitialisierer ------------------------------------------------------------------------ 322 Konstante Teilobjekte ------------------------------------------------------------------------ 324 Statische Datenelemente ------------------------------------------------------------------------ 326 Zugriff auf statische Datenelemente ------------------------------------------------------------------------ 328 Aufzdhlungen ------------------------------------------------------------------------ 330 UEbungen ------------------------------------------------------------------------ 334 Loesungen ------------------------------------------------------------------------ 341 16 Vektoren ------------------------------------------------------------------------ 342 Vektoren definieren ------------------------------------------------------------------------ 344 Initialisierung von Vektoren ------------------------------------------------------------------------ 346 C-Strings ------------------------------------------------------------------------ 348 Klassen-Arrays ------------------------------------------------------------------------ 350 Mehrdimensionale Vektoren ------------------------------------------------------------------------ 352 Vektoren als Datenelemente ------------------------------------------------------------------------ 354 UEbungen ------------------------------------------------------------------------ 358 Loesungen ------------------------------------------------------------------------ 369 17 Zeiger und Vektoren ------------------------------------------------------------------------ 370 Vektoren und Zeiger (1) ------------------------------------------------------------------------ 372 Vektoren und Zeiger (2) ------------------------------------------------------------------------ 374 Zeigerarithmetik ------------------------------------------------------------------------ 376 Vektoren als Argumente von Funktionen ------------------------------------------------------------------------ 378 Zeigerversion von Funktionen ------------------------------------------------------------------------ 380 Read-Only-Zeiger ------------------------------------------------------------------------ 382 Zeiger als Return-Wert ------------------------------------------------------------------------ 384 Zeigervektoren ------------------------------------------------------------------------ 386 Argumente aus der Kommandozeile ------------------------------------------------------------------------ 388 UEbungen ------------------------------------------------------------------------ 392 Loesungen ------------------------------------------------------------------------ 399 18 Grundlagen der Dateiverarbeitung ------------------------------------------------------------------------ 400 Dateien ------------------------------------------------------------------------ 402 File-Stream-Klassen ------------------------------------------------------------------------ 404 File-Streams anlegen ------------------------------------------------------------------------ 406 Eroeffnungsmodus ------------------------------------------------------------------------ 406 Flags fuer den Eroeffnungsmodus einer Datei --------------------------------------------------------------------------------- 406 Standartmaeszig wird eine Dateials ..."Cooked Modus" ... "Raw Modus" ... ios::IN | out | trunc | in | out HASH_DAT.CPP HashFile::HashFile(const string file, unsigned long n) throw(open_error) { ios::openmode mode = ios::in | ios::out | ios::binary; ... f.open(file.c_str(), mode); // OEffnen, falls Datei schon existiert. 407 Einem Flag entspricht stets ein einzelnes Bit in einem Rechnerwort. 408 Schlieszen von Dateien ------------------------------------------------------------------------ 410 Blockweises Schreiben und Lesen ------------------------------------------------------------------------ 412 Persistenz von Objekten ------------------------------------------------------------------------ 414 UEbungen ------------------------------------------------------------------------ 418 Loesungen ------------------------------------------------------------------------ 433 19 Operatoren |berladen ------------------------------------------------------------------------ 434 Allgemeines ------------------------------------------------------------------------ 436 Operatorfunktionen (1) ------------------------------------------------------------------------ 438 Operatorfunktionen (2) ------------------------------------------------------------------------ 440 UEberladene Operatoren verwenden ------------------------------------------------------------------------ 442 Globale Operatorfunktionen ------------------------------------------------------------------------ 444 friend-Funktionen ------------------------------------------------------------------------ 446 friend-Klassen ------------------------------------------------------------------------ 448 Index-Operator |berladen ------------------------------------------------------------------------ 450 Shift-Operatoren fuer die Ein-/Ausgabe |berladen ------------------------------------------------------------------------ 452 UEbungen ------------------------------------------------------------------------ 454 Loesungen ------------------------------------------------------------------------ 463 20 Typumwandlungen fuer Klassen ------------------------------------------------------------------------ 464 Konvertierungskonstruktoren ------------------------------------------------------------------------ 466 Konvertierungsfunktionen ------------------------------------------------------------------------ 468 Mehrdeutigkeit bei Typumwandlungen ------------------------------------------------------------------------ 470 UEbungen ------------------------------------------------------------------------ 472 Loesungen ------------------------------------------------------------------------ 475 21 Speicherreservierung zur Laufzeit ------------------------------------------------------------------------ 476 Der Operator new ------------------------------------------------------------------------ 478 Der Operator delete ------------------------------------------------------------------------ 480 Dynamischer Speicher fuer Klassen ------------------------------------------------------------------------ 482 Dynamischer Speicher fuer Vektoren ------------------------------------------------------------------------ 484 Anwendung: Einfach verkettete Listen ------------------------------------------------------------------------ 486 Darstellung einer einfach verketteten Liste ------------------------------------------------------------------------ 488 UEbungen ------------------------------------------------------------------------ 490 Loesungen ------------------------------------------------------------------------ 499 22 Dynamische Elemente ------------------------------------------------------------------------ 500 Datenfelder variabler Ldnge ------------------------------------------------------------------------ 502 Eine Klasse mit dynamischem Element ------------------------------------------------------------------------ 504 Auf- und Abbau eines Objekts ------------------------------------------------------------------------ 506 Die Implementierung der Methoden ------------------------------------------------------------------------ 508 Kopierkonstruktor ------------------------------------------------------------------------ 510 Zuweisung ------------------------------------------------------------------------ 512 UEbungen ------------------------------------------------------------------------ 514 Loesungen ------------------------------------------------------------------------ 523 23 Vererbung ------------------------------------------------------------------------ 524 Konzept der Vererbung ------------------------------------------------------------------------ 526 Abgeleitete Klassen ------------------------------------------------------------------------ 528 Elemente abgeleiteter Klassen ------------------------------------------------------------------------ 530 Elementzugriff ------------------------------------------------------------------------ 532 Redefinition von Elementen ------------------------------------------------------------------------ 534 Auf- und Abbau abgeleiteter Klassen ------------------------------------------------------------------------ 536 Objekte abgeleiteter Klassen ------------------------------------------------------------------------ 538 protected-Deklarationen ------------------------------------------------------------------------ 540 UEbungen ------------------------------------------------------------------------ 544 Loesungen ------------------------------------------------------------------------ 553 24 Typumwandlung in Klassenhierarchien ------------------------------------------------------------------------ 554 Konvertierung in Basisklassen ------------------------------------------------------------------------ 556 Typumwandlung bei Zuweisungen ------------------------------------------------------------------------ 558 Konvertierung von Referenzen und Zeigern ------------------------------------------------------------------------ 560 Explizite Typumwandlungen ------------------------------------------------------------------------ 562 UEbungen ------------------------------------------------------------------------ 564 Loesungen ------------------------------------------------------------------------ 567 25 Polymorphe Klassen ------------------------------------------------------------------------ 568 Polymorphie ------------------------------------------------------------------------ 570 Virtuelle Methoden ------------------------------------------------------------------------ 572 Abbau dynamischer Objekte ------------------------------------------------------------------------ 574 Virtuelle Methodentabelle ------------------------------------------------------------------------ 576 Dynamische Casts ------------------------------------------------------------------------ 578 UEbungen ------------------------------------------------------------------------ 582 Loesungen ------------------------------------------------------------------------ 589 26 Abstrakte Klassen ------------------------------------------------------------------------ 590 Rein virtuelle Methoden ------------------------------------------------------------------------ 592 Abstrakte und konkrete Klassen ------------------------------------------------------------------------ 594 Zeiger und Referenzen auf abstrakte Klassen ------------------------------------------------------------------------ 596 Virtuelle Zuweisungen ------------------------------------------------------------------------ 598 Anwendung: Inhomogene Listen ------------------------------------------------------------------------ 600 Implementierung einer inhomogenen Liste ------------------------------------------------------------------------ 602 UEbungen ------------------------------------------------------------------------ 604 Loesungen ------------------------------------------------------------------------ 611 27 Mehrfachvererbung ------------------------------------------------------------------------ 612 Mehrfach abgeleitete Klassen ------------------------------------------------------------------------ 614 Mehrfache indirekte Basisklassen ------------------------------------------------------------------------ 616 Virtuelle Basisklassen Aufrufe von Konstruktoren ------------------------------------------------------------------------ 618 Initialisierung virtueller Basisklassen ------------------------------------------------------------------------ 620 UEbungen ------------------------------------------------------------------------ 626 Loesungen ------------------------------------------------------------------------ 631 28 Ausnahmebehandlung ------------------------------------------------------------------------ 632 Traditionelle Fehlerbehandlung ------------------------------------------------------------------------ 634 Exception-Handling ------------------------------------------------------------------------ 636 Exception-Handler ------------------------------------------------------------------------ 638 Auslvsen und Auffangen von Exceptions ------------------------------------------------------------------------ 640 Schachteln von Ausnahmebehandlungen ------------------------------------------------------------------------ 642 Definition eigener Fehlerklassen ------------------------------------------------------------------------ 644 Standardfehlerklassen ------------------------------------------------------------------------ 646 UEbungen ------------------------------------------------------------------------ 650 Loesungen ------------------------------------------------------------------------ 661 29 Mehr |ber Dateien ------------------------------------------------------------------------ 662 Dateien fuer wahlfreien Zugriff vffnen ------------------------------------------------------------------------ 664 Wahlfreies Positionieren ------------------------------------------------------------------------ 666 Wahlfreies Positionieren (Fortsetzung) ------------------------------------------------------------------------ 668 Dateistatus ------------------------------------------------------------------------ 670 Exception-Handling fuer Dateien ------------------------------------------------------------------------ 672 Persistenz von polymorphen Objekten ------------------------------------------------------------------------ 674 Persistenz von Objekten (Fortsetzung) ------------------------------------------------------------------------ 676 Anwendung Indexdateien ------------------------------------------------------------------------ 678 Implementierung einer Indexdatei ------------------------------------------------------------------------ 680 UEbungen ------------------------------------------------------------------------ 684 Loesungen ------------------------------------------------------------------------ 705 30 Mehr |ber Zeiger ------------------------------------------------------------------------ 706 Zeiger auf Zeiger ------------------------------------------------------------------------ 708 Variable Anzahl von Argumenten ------------------------------------------------------------------------ 712 Zeiger auf Funktionen ------------------------------------------------------------------------ 714 Komplexe Deklarationen ------------------------------------------------------------------------ 716 Definition von Typnamen ------------------------------------------------------------------------ 718 Anwendung: Dynamische Matrizen ------------------------------------------------------------------------ 720 UEbungen ------------------------------------------------------------------------ 722 Loesungen ------------------------------------------------------------------------ 731 31 Bitmanipulationen ------------------------------------------------------------------------ 732 Logische Bitoperatoren ------------------------------------------------------------------------ 734 Shift-Operatoren ------------------------------------------------------------------------ 736 Bitmasken ------------------------------------------------------------------------ 738 Verwenden von Bitmasken ------------------------------------------------------------------------ 740 Bitfelder ------------------------------------------------------------------------ 742 UEbungen ------------------------------------------------------------------------ 744 Loesungen ------------------------------------------------------------------------ 749 32 Templates ------------------------------------------------------------------------ 750 Funktions- und Klassen-Templates ------------------------------------------------------------------------ 752 Definition von Templates ------------------------------------------------------------------------ 754 Instantiierung von Templates ------------------------------------------------------------------------ 756 Template-Parameter ------------------------------------------------------------------------ 758 Template-Argumente ------------------------------------------------------------------------ 760 Spezialisierungen ------------------------------------------------------------------------ 762 Default-Argumente von Templates ------------------------------------------------------------------------ 764 Explizite Instantiierung ------------------------------------------------------------------------ 766 UEbungen ------------------------------------------------------------------------ 770 Loesungen ------------------------------------------------------------------------ 777 33 Container ------------------------------------------------------------------------ 778 Arten von Containern ------------------------------------------------------------------------ 780 Sequentielle Container-Klassen ------------------------------------------------------------------------ 782 Iteratoren ------------------------------------------------------------------------ 784 Vereinbarung sequentieller Container ------------------------------------------------------------------------ 786 Einf|gen in sequentiellen Containern ------------------------------------------------------------------------ 788 Elementzugriff ------------------------------------------------------------------------ 790 Ldnge und Kapazitdt ------------------------------------------------------------------------ 792 Lvschen in sequentiellen Containern ------------------------------------------------------------------------ 794 Listenoperationen ------------------------------------------------------------------------ 796 Assoziative Container ------------------------------------------------------------------------ 798 Sets und Multisets ------------------------------------------------------------------------ 800 Maps und Multimaps ------------------------------------------------------------------------ 802 Bitsets ------------------------------------------------------------------------ 806 UEbungen ------------------------------------------------------------------------ 808 Loesungen ------------------------------------------------------------------------ Anhang ------------------------------------------------------------------------ 812 Binaere Zahlendarstellung ------------------------------------------------------------------------ 815 Praeprozessor-Direktiven ------------------------------------------------------------------------ 821 Vordefinierte Standardmakros ------------------------------------------------------------------------ 822 Einbinden von C-Funktionen ------------------------------------------------------------------------ 824 Operatorenuebersicht ------------------------------------------------------------------------ 826 Vorrangtabelle fuer Operatoren ------------------------------------------------------------------------ 827 ASCII-Code-Tabelle ------------------------------------------------------------------------ 828 Bildschirmsteuerzeichen ------------------------------------------------------------------------ 829 Die CD-ROM zum Buch ------------------------------------------------------------------------ 833 Stichwortverzeichnis ------------------------------------------------------------------------ ******* EOF ************************************************************