Jürgen Wolf

Grundkurs C++

Auf einen Blick 1

Einstieg in die Welt von C++ ...................................

15

2

Verwendung der Basisdatentypen in C++ ...............

23

3

Kontrollstrukturen, Funktionen und Präprozessor-Direktiven ..........................................

67

4

Höhere und fortgeschrittene Datentypen ............... 123

5

Modularisierung ...................................................... 179

6

Klassen .................................................................... 203

7

Objekte und Klassenelemente ................................ 233

8

Operatoren überladen ............................................. 273

9

Vererbung (Abgeleitete Klassen) ............................. 299

10

Abstrakte Klassen .................................................... 325

11

Templates ................................................................ 335

12

Exception-Handling (Fehlerbehandlung) ................. 359

Inhalt 1

2

Einstieg in die Welt von C++ ....................................

15

1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8

Die (Kurz-)Geschichte von C++ .............................. Der ANSI-C++-Standard ......................................... Was benötige ich für C++? ..................................... Welches Betriebssystem ...? ................................... Schreibkonventionen ............................................. Was kann ich von dem Buch erwarten? .................. Listings zum Buch .................................................. Aufgaben im Buch .................................................. 1.8.1 Level 1 ........................................................ 1.8.2 Level 2 ........................................................ 1.8.3 Level 3 ........................................................

15 17 18 20 20 21 21 21 21 22 22

Verwendung der Basisdatentypen in C++ ................

23

2.1 2.2

23 26 26 27 28 29 30 30 31 32 33 33 35 35 42 44

2.3

2.4

Das erste Programm in C++ .................................... Die Standard-Ein-/Ausgabestreams ......................... 2.2.1 Die Streams von C++ ................................... 2.2.2 Ausgabe mit »cout« ..................................... 2.2.3 Ausgabe mit »cerr« oder »clog« ................... 2.2.4 Eingabe mit »cin« ........................................ Einige Symbole von C++ ........................................ 2.3.1 Bezeichner ................................................... 2.3.2 Literale ........................................................ 2.3.3 Kommentare ............................................... Grundlagen zu den Basisdatentypen ....................... 2.4.1 Deklaration und Definition .......................... 2.4.2 Initialisieren einer Variablen ......................... 2.4.3 Ganzzahltypen ............................................. 2.4.4 Vorzeichenlos und vorzeichenbehaftet ......... 2.4.5 Fließkommazahlentypen ..............................

5

Inhalt

2.4.6 Limits für die Basisdatentypen ..................... Rechnen mit Zahlen ............................................... 2.5.1 Arithmetische Operatoren ........................... 2.5.2 Ungenaue Fließkommazahlen ...................... 2.5.3 Erweiterte Darstellung arithmetischer Operatoren .................................................. 2.5.4 Inkrement- und Dekrementoperator ............ Typumwandlung .................................................... 2.6.1 Implizite Umwandlung des Compilers .......... 2.6.2 Explizite Typumwandlung ............................ 2.6.3 Neue C++-Typumwandlungs-Operatoren .... Konstanten ............................................................ Aufgaben ............................................................... 2.8.1 Level 1 ........................................................ 2.8.2 Level 2 ........................................................ 2.8.3 Level 3 ........................................................

52 52 54 54 58 60 63 63 64 64 65

Kontrollstrukturen, Funktionen und Präprozessor-Direktiven ...........................................

67

2.5

2.6

2.7 2.8

3

3.1

3.2

6

Kontrollstrukturen .................................................. 3.1.1 Anweisungen und Anweisungsblöcke .......... 3.1.2 Verzweigungen ............................................ 3.1.3 Der Bedingungsoperator ?: .......................... 3.1.4 Logische Operatoren ................................... 3.1.5 Die Fallunterscheidung – »switch« ............... 3.1.6 Schleifen ...................................................... Funktionen ............................................................ 3.2.1 Funktionen definieren ................................. 3.2.2 Funktionen aufrufen .................................... 3.2.3 Funktionen deklarieren ................................ 3.2.4 Funktionsparameter (Call-by-Value) ............. 3.2.5 Standardparameter ...................................... 3.2.6 Rückgabewert von Funktionen ....................

46 47 48 50

67 67 68 76 76 79 82 92 93 94 95 96 97 99

Inhalt

3.2.7 3.2.8

3.3

3.4

4

Funktionen überladen ............................... Gültigkeitsbereich von lokalen und globalen Variablen ..................................... 3.2.9 Inline-Funktionen ...................................... 3.2.10 Die »main«-Funktion ................................. 3.2.11 Programmende .......................................... Präprozessor-Direktiven ......................................... 3.3.1 Die »#include«-Direktive ........................... 3.3.2 Die »#define«-Direktive ............................. 3.3.3 Bedingte Kompilierung .............................. 3.3.4 Weitere Präprozessor-Direktiven ............... Aufgaben ............................................................... 3.4.1 Level 1 ...................................................... 3.4.2 Level 2 ...................................................... 3.4.3 Level 3 ......................................................

101 103 105 106 107 108 109 111 116 118 119 119 120 121

Höhere und fortgeschrittene Datentypen ................ 123 4.1

4.2 4.3

4.4

Zeiger .................................................................... 123 4.1.1 Zeiger deklarieren ...................................... 124 4.1.2 Adresse im Zeiger speichern ...................... 124 4.1.3 Zeiger dereferenzieren ............................... 126 4.1.4 Speichergröße von Zeigern ........................ 128 4.1.5 Zeigerarithmetik ........................................ 129 4.1.6 Mehrfache Indirektion ............................... 130 4.1.7 void-Zeiger ................................................ 130 Referenzen ............................................................. 131 Arrays .................................................................... 133 4.3.1 Der C++-Standardtyp »vector« .................. 133 4.3.2 C-Arrays .................................................... 136 Zeichenketten verwenden ...................................... 140 4.4.1 Der C++-Standardtyp »string« ................... 140 4.4.2 C-Zeichenketten ........................................ 142

7

Inhalt

4.5

4.6

4.7

4.8

4.9 4.10 4.11 4.12

8

C-Arrays und C-Strings versus Zeiger ...................... 4.5.1 C-Array und Zeiger .................................... 4.5.2 C-String und Zeiger ................................... 4.5.3 Zeigerarrays ............................................... Höhere Datentypen bei Funktionen verwenden ..... 4.6.1 Zeiger als Funktionsparameter ................... 4.6.2 Zeiger als Rückgabewert ............................ 4.6.3 Referenzen als Funktionsparameter ........... 4.6.4 Referenzen als Rückgabewert .................... 4.6.5 C-Arrays oder C-Strings als Funktionsparameter ................................... Dynamische Speicherobjekte .................................. 4.7.1 Dynamisch Objekte mit »new« anlegen ..... 4.7.2 Fehler bei der Speicheranforderung abfangen ................................................... 4.7.3 Speicher mit »delete« wieder freigeben ..... Strukturen .............................................................. 4.8.1 Strukturen deklarieren ............................... 4.8.2 Zugriff auf die Strukturelemente ................ 4.8.3 Zugriff auf die Elemente über Strukturzeiger ............................................ 4.8.4 Strukturen vergleichen ............................... 4.8.5 Dynamische Datenstrukturen mit Strukturen ................................................. Union ..................................................................... Aufzählungstyp »enum« ......................................... Eigene Namen mit »typedef« ................................. Aufgaben ............................................................... 4.12.1 Level 1 ...................................................... 4.12.2 Level 2 ...................................................... 4.12.3 Level 3 ......................................................

144 145 147 148 149 150 152 153 154 157 159 160 162 162 164 165 165 166 168 168 172 173 174 175 175 176 177

Inhalt

5

Modularisierung ....................................................... 179 5.1

5.2

5.3

5.4 5.5

5.6

6

Namensräume ........................................................ 179 5.1.1 Neuen Namensbereich deklarieren .............. 179 5.1.2 Namensbereich verschachteln ..................... 181 5.1.3 Namensbereich ist ein eigener Gültigkeitsbereich ........................................ 181 5.1.4 Namensbereich mit »using« importieren ...... 184 5.1.5 Einzelne Bezeichner mit »using« importieren ................................................. 185 5.1.6 Aliasse für Namensbereiche ......................... 185 Speicherklassenattribute ......................................... 185 5.2.1 Schlüsselwort »extern« ................................ 186 5.2.2 Schlüsselwort »static« .................................. 186 5.2.3 Schlüsselwort »register« ............................... 189 5.2.4 Schlüsselwort »auto« ................................... 190 Typqualifikatoren ................................................... 191 5.3.1 Schlüsselwort »const« .................................. 191 5.3.2 Schlüsselwort »volatile« ............................... 192 Funktionsattribute .................................................. 193 Modulare Programmierung .................................... 193 5.5.1 Aufteilung ................................................... 194 5.5.2 Die öffentliche Schnittstelle (Headerdatei) ... 196 5.5.3 Private Datei(en) .......................................... 197 5.5.4 Die Client-Datei .......................................... 198 5.5.5 Nur Objektcode oder Bibliothek vorhanden ................................................... 199 Aufgaben ............................................................... 199 5.6.1 Level 1 ........................................................ 199 5.6.2 Level 2 ........................................................ 200

Klassen ..................................................................... 203 6.1 6.2

Abstraktionsmechanismus ...................................... Klassen ..................................................................

203 204

9

Inhalt

6.2.1 6.2.2 6.2.3 6.2.4

6.3

6.4

6.5

6.6

7

204 205 207 210 210 215 216 217 219 220 221 221 222 224 224 227 229 230 230 231 232

Objekte und Klassenelemente ................................. 233 7.1 7.2

7.3

10

Klassendefinition ......................................... Elementfunktionen definieren ...................... Zugriffskontrolle mit »public« und »private« Zugriff auf die Daten innerhalb einer Klasse .......................................................... 6.2.5 Objekte erzeugen und benutzen .................. Konstruktoren ........................................................ 6.3.1 Konstruktoren deklarieren ........................... 6.3.2 Konstruktoren definieren ............................. 6.3.3 Standardkonstruktor (Default-Konstruktor) ... 6.3.4 Kopierkonstruktor ....................................... Destruktoren .......................................................... 6.4.1 Destruktor deklarieren ................................. 6.4.2 Destruktor definieren .................................. Elementfunktionen ................................................. 6.5.1 Inline-Elementfunktionen ............................ 6.5.2 Konstante Elementfunktionen (read-only) .... 6.5.3 this-Zeiger ................................................... Aufgaben ............................................................... 6.6.1 Level 1 ........................................................ 6.6.2 Level 2 ........................................................ 6.6.3 Level 3 ........................................................

Konstante Objekte ................................................. Objekte als (Element-)Funktionsargumente ............ 7.2.1 Hilfsfunktionen ............................................ 7.2.2 Wertübergabe als Kopie (Call-by-Value) ...... 7.2.3 Wertübergabe als Zeiger (Call-by-Reference) 7.2.4 Wertübergabe als Referenz .......................... 7.2.5 Wertübergabe bei Elementfunktionen ......... 7.2.6 *this-Zeiger ................................................. Objekte als Rückgabewerte ....................................

233 234 234 235 237 239 239 242 244

Inhalt

7.4 7.5 7.6

7.7 7.8 7.9

8

Arrays von Objekten .............................................. 246 Dynamische Objekte .............................................. 247 Mehr zu den Klassenelementen .............................. 250 7.6.1 Dynamische Klassenelemente ...................... 250 7.6.2 Statische Klassenelemente ........................... 257 Andere Klassenobjekte als Datenelement einer Klasse ............................................................ 260 Gute Freunde (»friend«) ......................................... 267 Aufgaben ............................................................... 270 7.9.1 Level 1 ........................................................ 270 7.9.2 Level 2 ........................................................ 270 7.9.3 Level 3 ........................................................ 272

Operatoren überladen .............................................. 273 8.1 8.2

8.3 8.4 8.5

8.6 8.7

8.8

Schlüsselwort »operator« ....................................... Zweistellige (arithmetische) Operatoren überladen .............................................................. 8.2.1 Operatorüberladung als Elementfunktion einer Klasse ................................................. 8.2.2 Operatorüberladung als globale Hilfsfunktion ................................................ 8.2.3 Zweistellige Operatoren zusammengefasst ... Einstellige Operatoren überladen ........................... Zuweisungsoperator überladen .............................. Ein-/Ausgabeoperator überladen ............................ 8.5.1 Eingabeoperator >> überladen ..................... 8.5.2 Ausgabeoperator