Leseproben und Inhaltsverzeichnis - mitp
Werbung
Inhaltsverzeichnis
Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1
Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Entwicklung und Eigenschaften von C++ . . . . . . . . . . . . . . . . . . . . . 24
Objektorientierte Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . 26
Erstellen eines C++-Programms . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Ein erstes C++-Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
Struktur einfacher C++-Programme. . . . . . . . . . . . . . . . . . . . . . . . . 32
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
2
Elementare Datentypen, Konstanten und Variablen . . 37
Elementare Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
Konstanten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
Escape-Sequenzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
Namen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
Variablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
Die Schlüsselworte const und volatile . . . . . . . . . . . . . . . . . . . . . . . . 54
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
3
Verwenden von Funktionen und Klassen . . . . . . . . . . . 61
Deklaration von Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
Aufruf von Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
Der Typ void für Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
Header-Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
Standard-Header-Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
Verwenden von Standardklassen . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
7
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
C++ Lernen und professionell anwenden
4
Ein- und Ausgaben mit Streams . . . . . . . . . . . . . . . . . 79
Streams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
Formatierung und Manipulatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
Formatierte Ausgabe von Ganzzahlen . . . . . . . . . . . . . . . . . . . . . . . 84
Formatierte Ausgabe von Gleitpunktzahlen. . . . . . . . . . . . . . . . . . . . 86
Ausgabe in Felder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
Ausgabe von Zeichen, Strings und booleschen Werten . . . . . . . . . . . 90
Formatierte Eingabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
Formatierte Eingabe von Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
Unformatierte Ein-/Ausgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
5
Operatoren für elementare Datentypen . . . . . . . . . . 103
Binäre arithmetische Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . 104
Unäre arithmetische Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . 106
Zuweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
Vergleichsoperatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
Logische Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
6
Kontrollstrukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
Die while-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
Die for-Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
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
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
8
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Inhaltsverzeichnis
7
Symbolische Konstanten und Makros . . . . . . . . . . . . 141
Makros. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
Makros mit Parametern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
Arbeiten mit der #define-Direktive . . . . . . . . . . . . . . . . . . . . . . . . . 146
Bedingte Kompilierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
Standardmakros zur Behandlung von Zeichen. . . . . . . . . . . . . . . . . 150
Umlenken von Standardeingabe und -ausgabe. . . . . . . . . . . . . . . . 152
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
8
Umwandlung arithmetischer Datentypen . . . . . . . . . 161
Implizite Typumwandlungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
Verfahren bei arithmetischen Typumwandlungen . . . . . . . . . . . . . . 164
Implizite Typumwandlungen bei Zuweisungen . . . . . . . . . . . . . . . . 166
Weitere Typumwandlungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
9
Die Standardklasse string . . . . . . . . . . . . . . . . . . . . . 175
Definition und Zuweisung von Strings . . . . . . . . . . . . . . . . . . . . . . . 176
Verketten von Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
Strings vergleichen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
Einfügen und Löschen in Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
Suchen und Ersetzen in Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
Zugriff auf Zeichen in Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
10 Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
Bedeutung von Funktionen in C++ . . . . . . . . . . . . . . . . . . . . . . . . 194
Erstellen eigener Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
Return-Wert von Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
Übergabe von Argumenten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
9
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
C++ Lernen und professionell anwenden
inline-Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
Default-Argumente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
Überladen von Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
Rekursive Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
Platzhalter auto für Return-Typen . . . . . . . . . . . . . . . . . . . . . . . . . . 210
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215
11 Speicherklassen und Namensbereiche . . . . . . . . . . . 221
Speicherklasse von Objekten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
Der Speicherklassen-Spezifizierer extern . . . . . . . . . . . . . . . . . . . . . 224
Der Speicherklassen-Spezifizierer static. . . . . . . . . . . . . . . . . . . . . . 226
Die Speicherklassen-Spezifizierer auto und register. . . . . . . . . . . . . 228
Speicherklassen-Spezifizierer von Funktionen . . . . . . . . . . . . . . . . . 230
Namensbereiche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232
Das Schlüsselwort using . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240
12 Referenzen und Zeiger . . . . . . . . . . . . . . . . . . . . . . . 245
Definition von Referenzen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
Referenzen als Parameter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248
Referenzen als Return-Wert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250
Ausdrücke mit Referenztyp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252
Definition von Zeigern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254
Der Verweisoperator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256
Zeiger als Parameter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
13 Definition von Klassen . . . . . . . . . . . . . . . . . . . . . . . . 267
Klassen-Konzept. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268
Definition von Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270
10
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Inhaltsverzeichnis
Definition von Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
Definition von Objekten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
Verwendung von Objekten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276
Zeiger auf Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278
Structs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280
Unions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284
Lösung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286
14 Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289
Konstruktoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290
Aufruf von Konstruktoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292
Mehr Initialisierungsmöglichkeiten . . . . . . . . . . . . . . . . . . . . . . . . . 294
Destruktoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296
Inline-Methoden. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298
Zugriffsmethoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300
const-Objekte und -Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302
Standardmethoden. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304
Standardmethoden kontrollieren . . . . . . . . . . . . . . . . . . . . . . . . . . 306
Der this-Zeiger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308
Übergabe von Objekten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310
Objekte als Return-Wert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318
15 Teilobjekte und statische Elemente . . . . . . . . . . . . . . 325
Klassen mit Teilobjekten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326
Elementinitialisierer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328
Konstante Teilobjekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
Statische Datenelemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332
Zugriff auf statische Datenelemente . . . . . . . . . . . . . . . . . . . . . . . . 334
Aufzählungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342
11
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
C++ Lernen und professionell anwenden
16 Vektoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349
Vektoren definieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350
Initialisierung von Vektoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352
C-Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354
Klassen-Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356
Mehrdimensionale Vektoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358
Vektoren als Datenelemente. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366
17 Zeiger und Vektoren . . . . . . . . . . . . . . . . . . . . . . . . . 377
Vektoren und Zeiger (1) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
Vektoren und Zeiger (2) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 380
Zeigerarithmetik. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382
Vektoren als Argumente von Funktionen. . . . . . . . . . . . . . . . . . . . . 384
Zeigerversion von Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386
Read-Only-Zeiger. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388
Zeiger als Return-Wert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390
Zeigervektoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392
Argumente aus der Kommandozeile . . . . . . . . . . . . . . . . . . . . . . . . 394
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400
18 Grundlagen der Dateiverarbeitung . . . . . . . . . . . . . . 407
Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408
File-Stream-Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 410
File-Streams anlegen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412
Eröffnungsmodus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 414
Schließen von Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416
Blockweises Schreiben und Lesen . . . . . . . . . . . . . . . . . . . . . . . . . . 418
Persistenz von Objekten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 422
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426
12
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Inhaltsverzeichnis
19 Operatoren überladen . . . . . . . . . . . . . . . . . . . . . . . 441
Allgemeines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 442
Operatorfunktionen (1) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444
Operatorfunktionen (2) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446
Überladene Operatoren verwenden . . . . . . . . . . . . . . . . . . . . . . . . 448
Globale Operatorfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 450
friend-Funktionen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 452
friend-Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454
Index-Operator überladen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456
Shift-Operatoren für die Ein-/Ausgabe überladen . . . . . . . . . . . . . . 458
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 460
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 462
20 Typumwandlungen für Klassen . . . . . . . . . . . . . . . . . 471
Konvertierungskonstruktoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 472
Konvertierungsfunktionen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 474
Mehrdeutigkeit bei Typumwandlungen . . . . . . . . . . . . . . . . . . . . . . 476
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 478
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 480
21 Speicherreservierung zur Laufzeit . . . . . . . . . . . . . . . 483
Der Operator new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 484
Der Operator delete. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 486
Dynamischer Speicher für Klassen . . . . . . . . . . . . . . . . . . . . . . . . . 488
Dynamischer Speicher für Vektoren . . . . . . . . . . . . . . . . . . . . . . . . 490
Anwendung: Einfach verkettete Listen . . . . . . . . . . . . . . . . . . . . . . . 492
Darstellung einer einfach verketteten Liste . . . . . . . . . . . . . . . . . . . 494
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 496
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 498
22 Dynamische Elemente . . . . . . . . . . . . . . . . . . . . . . . . 507
Datenfelder variabler Länge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 508
Eine Klasse mit dynamischem Element . . . . . . . . . . . . . . . . . . . . . . 510
Auf- und Abbau eines Objekts . . . . . . . . . . . . . . . . . . . . . . . . . . . . 512
13
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
C++ Lernen und professionell anwenden
Die Implementierung der Methoden . . . . . . . . . . . . . . . . . . . . . . . . 514
Kopierkonstruktor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 516
Zuweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 518
Verschieben von R-Werten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 520
Move-Konstruktor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 522
Move-Zuweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 524
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 526
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 528
23 Vererbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 537
Konzept der Vererbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 538
Abgeleitete Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 540
Elemente abgeleiteter Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 542
Elementzugriff . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 544
Redefinition von Elementen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 546
Auf- und Abbau abgeleiteter Klassen . . . . . . . . . . . . . . . . . . . . . . . 548
Objekte abgeleiteter Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 550
protected-Deklarationen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 552
Weitere Zugriffseinschränkungen . . . . . . . . . . . . . . . . . . . . . . . . . . 554
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 556
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 560
24 Typumwandlung in Klassenhierarchien . . . . . . . . . . . 569
Konvertierung in Basisklassen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 570
Typumwandlung bei Zuweisungen . . . . . . . . . . . . . . . . . . . . . . . . . 572
Konvertierung von Referenzen und Zeigern. . . . . . . . . . . . . . . . . . . 574
Explizite Typumwandlungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 576
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 578
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 580
25 Polymorphe Klassen . . . . . . . . . . . . . . . . . . . . . . . . . 583
Polymorphie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 584
Virtuelle Methoden. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 586
Abbau dynamischer Objekte. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 588
14
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Inhaltsverzeichnis
Virtuelle Methodentabelle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 590
Dynamische Casts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 592
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 598
26 Abstrakte Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . 605
Rein virtuelle Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 606
Abstrakte und konkrete Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . 608
Zeiger und Referenzen auf abstrakte Klassen . . . . . . . . . . . . . . . . . 610
Virtuelle Zuweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 612
Anwendung: Inhomogene Listen. . . . . . . . . . . . . . . . . . . . . . . . . . . 614
Implementierung einer inhomogenen Liste . . . . . . . . . . . . . . . . . . . 616
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 618
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 620
27 Mehrfachvererbung . . . . . . . . . . . . . . . . . . . . . . . . . . 627
Mehrfach abgeleitete Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 628
Mehrfache indirekte Basisklassen . . . . . . . . . . . . . . . . . . . . . . . . . . 630
Virtuelle Basisklassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 632
Aufrufe von Konstruktoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 634
Initialisierung virtueller Basisklassen . . . . . . . . . . . . . . . . . . . . . . . . 636
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 638
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 642
28 Ausnahmebehandlung . . . . . . . . . . . . . . . . . . . . . . . 647
Traditionelle Fehlerbehandlung . . . . . . . . . . . . . . . . . . . . . . . . . . . 648
Exception-Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 650
Exception-Handler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 652
Auslösen und Auffangen von Exceptions . . . . . . . . . . . . . . . . . . . . . 654
Schachteln von Ausnahmebehandlungen . . . . . . . . . . . . . . . . . . . . 656
Definition eigener Fehlerklassen. . . . . . . . . . . . . . . . . . . . . . . . . . . 658
Standardfehlerklassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 660
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 662
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 666
15
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
C++ Lernen und professionell anwenden
29 Mehr über Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . 677
Dateien für wahlfreien Zugriff öffnen . . . . . . . . . . . . . . . . . . . . . . . 678
Wahlfreies Positionieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 680
Wahlfreies Positionieren (Fortsetzung). . . . . . . . . . . . . . . . . . . . . . . 682
Dateistatus. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 684
Exception-Handling für Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . 686
Persistenz von polymorphen Objekten . . . . . . . . . . . . . . . . . . . . . . 688
Persistenz von Objekten (Fortsetzung) . . . . . . . . . . . . . . . . . . . . . . . 690
Anwendung: Indexdateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 692
Implementierung eines Index-Dateisystems. . . . . . . . . . . . . . . . . . . 694
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 696
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 700
30 Mehr über Zeiger . . . . . . . . . . . . . . . . . . . . . . . . . . . 721
Zeiger auf Zeiger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 722
Variable Anzahl von Argumenten . . . . . . . . . . . . . . . . . . . . . . . . . . 724
Zeiger auf Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 728
Komplexe Deklarationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 730
Definition von Typnamen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 732
Matrizen als Argumente von Funktionen . . . . . . . . . . . . . . . . . . . . . 734
Anwendung: Dynamische Matrizen . . . . . . . . . . . . . . . . . . . . . . . . . 736
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 738
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 740
31 Bitmanipulationen . . . . . . . . . . . . . . . . . . . . . . . . . . . 749
Logische Bitoperatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 750
Shift-Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 752
Bitmasken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 754
Verwenden von Bitmasken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 756
Bitfelder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 758
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 760
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 762
16
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Inhaltsverzeichnis
32 Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 767
Funktions- und Klassen-Templates . . . . . . . . . . . . . . . . . . . . . . . . . 768
Definition von Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 770
Instantiierung von Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 772
Template-Parameter. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 774
Template-Argumente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 776
Spezialisierungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 778
Default-Argumente von Templates . . . . . . . . . . . . . . . . . . . . . . . . . 780
Explizite Instantiierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 782
Variable Anzahl von Parametern. . . . . . . . . . . . . . . . . . . . . . . . . . . 784
Standard-Templates für Bitsets . . . . . . . . . . . . . . . . . . . . . . . . . . . . 786
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 790
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 794
33 Container . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 801
Arten von Containern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 802
Sequenzielle Container-Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . 804
Iteratoren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 806
Vereinbarung sequenzieller Container . . . . . . . . . . . . . . . . . . . . . . 808
Einfügen in sequenziellen Containern . . . . . . . . . . . . . . . . . . . . . . . 810
Elementzugriff . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 812
Größe von Containern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 814
Löschen in sequenziellen Containern . . . . . . . . . . . . . . . . . . . . . . . 816
Listenoperationen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 818
Assoziative Container . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 820
Sets und Multisets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 822
Maps und Multimaps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 824
Initialisierungslisten und Range-for-Schleifen . . . . . . . . . . . . . . . . . 826
Hash-Tabellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 828
Ungeordnete assoziative Container . . . . . . . . . . . . . . . . . . . . . . . . 830
Hash-Tabellen für selbstdefinierte Typen. . . . . . . . . . . . . . . . . . . . . 832
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 834
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 838
17
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
C++ Lernen und professionell anwenden
34 Smart Pointer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 847
Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 848
Die Smart Pointer der Standardbibliothek . . . . . . . . . . . . . . . . . . . . 850
Smart Pointer vom Typ unique_ptr<T> einsetzen . . . . . . . . . . . . . . 852
Smart Pointer vom Typ unique_ptr<T> einsetzen (2) . . . . . . . . . . . . 854
Das Klassen-Template shared_ptr . . . . . . . . . . . . . . . . . . . . . . . . . . 856
Das Klassen-Template shared_ptr (2) . . . . . . . . . . . . . . . . . . . . . . . 858
Das Klassen-Template shared_ptr (3) . . . . . . . . . . . . . . . . . . . . . . . 860
Das Klassen-Template weak_ptr . . . . . . . . . . . . . . . . . . . . . . . . . . . 862
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 864
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 868
35 Multithreading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 879
Threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 880
Erzeugen und Ausführen von Threads . . . . . . . . . . . . . . . . . . . . . . . 882
Initialisierung und Zuweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 884
Konkurrierende Speicherzugriffe. . . . . . . . . . . . . . . . . . . . . . . . . . . 886
Thread-ID . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 888
Locks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 890
Bedingungsvariablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 892
Bedingungsvariablen (Fortsetzung) . . . . . . . . . . . . . . . . . . . . . . . . . 894
Übungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 896
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 900
36 Algorithmen der Standardbibliothek . . . . . . . . . . . . . 907
Algorithmen: Grundlagen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 908
Funktionsobjekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 910
Lambda-Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 914
Algorithmen und Iteratoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 916
Vordefinierte Iteratoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 918
Nicht-modifizierende Algorithmen . . . . . . . . . . . . . . . . . . . . . . . . . 920
Modifizierende Algorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 924
Mutierende Algorithmen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 928
Sortieren und verwandte Operationen . . . . . . . . . . . . . . . . . . . . . . 930
18
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Inhaltsverzeichnis
37 Numerische Bibliothek . . . . . . . . . . . . . . . . . . . . . . . . 935
Komplexe Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 936
Das Klassen-Template complex<T> . . . . . . . . . . . . . . . . . . . . . . . . 938
Methoden von complex<T> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 940
Komplexe Funktionen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 942
Das Klassen-Template valarray<T> . . . . . . . . . . . . . . . . . . . . . . . . 944
Zuweisung numerischer Vektoren . . . . . . . . . . . . . . . . . . . . . . . . . . 946
Arithmetische Operationen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 948
Weitere Operationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 950
Selektive Indizierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 952
Verallgemeinerte selektive Indizierung . . . . . . . . . . . . . . . . . . . . . . 954
Verallgemeinerte selektive Indizierung (Forts.) . . . . . . . . . . . . . . . . 956
Indirekte und maskierte Indizierung . . . . . . . . . . . . . . . . . . . . . . . . 958
Anhang A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 961
Binäre Zahlendarstellung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 962
Präprozessor-Direktiven . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 965
Vordefinierte Standardmakros . . . . . . . . . . . . . . . . . . . . . . . . . . . . 971
Einbinden von C-Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 972
Operatorenübersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 974
Vorrangtabelle für Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . 976
ASCII-Code-Tabelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 977
Bildschirmsteuerzeichen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 979
Compiler, Beispiele und Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . 980
Anhang B . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 983
Glossar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 983
Stichwortverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . 1003
19
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Kapitel 1
Grundlagen
Dieses Kapitel beschreibt die grundlegenden Eigenschaften der objektorientierten Programmiersprache C++. Außerdem werden die Schritte vorgestellt, die
zur Erstellung eines lauffähigen C++-Programms erforderlich sind. Diese
Schritte können Sie auf Ihrem System anhand von einführenden Beispielen
nachvollziehen. Die Beispiele dienen auch dazu, die grundlegende Struktur
eines C++-Programms darzustellen.
23
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Kapitel 1
C++ Lernen und professionell anwenden
Entwicklung und Eigenschaften von C++
Charakteristische Eigenschaften
24
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Grundlagen
Historisches
Die Programmiersprache C++ wurde von Bjarne Stroustrup und seinen Mitarbeitern in den Bell Laboratories (AT&T, USA) entwickelt, um Simulationsprojekte objektorientiert und effizient implementieren zu können. Frühe Versionen,
die zunächst als „C mit Klassen“ bezeichnet wurden, gibt es seit 1980. Der Name
C++ weist darauf hin, dass C++ aus der Programmiersprache C hervorgegangen
ist: ++ ist der Inkrementoperator von C.
Schon 1989 wurde ein ANSI-Komitee (American National Standards Institute)
gebildet, um die Programmiersprache C++ zu standardisieren. Hierbei geht es
darum, dass möglichst viele Compilerbauer und Software-Entwickler sich auf
eine einheitliche Sprachbeschreibung einigen, um die Bildung von Dialekten
und „Sprachverwirrungen“ zu vermeiden.
Anfang 1998 wurde von der ISO (International Organization for Standardization) der Standard für C++ (14882) verabschiedet, der 2003 erweitert und im
Oktober 2011 wesentlich ergänzt wurde. Der neueste Standard von 2011 wird
auch kurz mit C++11 bezeichnet.
Eigenschaften von C++
C++ ist keine rein objektorientierte Sprache, sondern eine Hybridsprache
(= „Mischsprache“): Sie enthält die Programmiersprache C als Teilmenge. Damit
hat man zunächst alle Möglichkeiten, die auch C bietet:
●
universell einsetzbare, modulare Programme
●
effiziente, maschinennahe Programmierung
●
Portabilität, d.h. Übertragbarkeit von Programmen auf verschiedene Rechner
Insbesondere kann die umfangreiche in C entwickelte Software auch in C++Programmen verwendet werden.
C++ unterstützt die Konzepte der objektorientierten Programmierung, nämlich:
●
Datenabstraktion, d.h. Bildung von Klassen zur Beschreibung von Objekten
●
Datenkapselung für den kontrollierten Zugriff auf die Daten von Objekten
●
Vererbung durch Bildung abgeleiteter Klassen (auch mehrfach)
●
Polymorphie (griech. „Vielgestaltigkeit“), d.h. die Implementierung von
Anweisungen, die zur Laufzeit verschiedene Wirkungen haben können
C++ wurde um zusätzliche Sprachelemente erweitert, wie z.B. Referenzen, Templates und Ausnahmebehandlung (engl. Exception Handling). Auch wenn diese
Sprachelemente keinen direkten Bezug zur Objektorientierung haben, sind sie
für deren effiziente Implementierung wichtig.
25
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Kapitel 1
C++ Lernen und professionell anwenden
Objektorientierte Programmierung
Traditionelles Konzept
Objektorientiertes Konzept
26
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Grundlagen
Klassische, prozedurale Programmierung
Die traditionelle, prozedurale Programmierung trennt Daten und Funktionen
(= Unterprogramme, Prozeduren), die diese Daten bearbeiten. Dies hat wichtige
Konsequenzen für den Umgang mit den Daten in einem Programm:
●
Der Programmierer muss selbst dafür sorgen, dass Daten vor ihrer Verwendung mit geeigneten Anfangswerten versehen sind und dass beim Aufruf
einer Funktion korrekte Daten übergeben werden.
●
Wird die Darstellung der Daten geändert, z.B. ein Datensatz erweitert, so
müssen auch die zugehörigen Funktionen entsprechend angepasst werden.
Beides ist natürlich fehleranfällig und nicht besonders wartungsfreundlich.
Objekte
Die objektorientierte Programmierung (OOP) stellt die Objekte in den Mittelpunkt, d.h. die Dinge, um die es bei der jeweiligen Problemstellung geht. Ein
Programm zur Verwaltung von Konten beispielsweise arbeitet mit Kontoständen, Kreditlimits, Überweisungen, Zinsberechnungen usw. Ein Objekt, das ein
Konto in einem Programm darstellt, besitzt dann die Eigenschaften und Fähigkeiten, die für die Kontoverwaltung wichtig sind.
Die Objekte in der OOP bilden eine Einheit aus Daten (= Eigenschaften) und
Funktionen (= Fähigkeiten). Mit einer Klasse wird ein Objekt-Typ definiert, der
sowohl die Eigenschaften als auch die Fähigkeiten von Objekten dieses Typs
festlegt. Die Kommunikation zwischen Objekten erfolgt dann durch „Nachrichten“, die die Fähigkeiten von Objekten aktivieren.
Vorteile der OOP
Für die Software-Entwicklung hat die objektorientierte Programmierung
wesentliche Vorteile:
●
geringere Fehleranfälligkeit: Ein Objekt kontrolliert den Zugriff auf seine
Daten selbst. Insbesondere kann es fehlerhafte Zugriffe abwehren.
●
gute Wiederverwendbarkeit: Ein Objekt verwaltet sich selbst. Es kann deshalb wie ein Baustein in beliebigen Programmen eingesetzt werden.
●
geringer Wartungsaufwand: Ein Objekt kann die interne Darstellung seiner
Daten an neue Anforderungen anpassen, ohne dass ein Anwendungsprogramm etwas davon merkt.
27
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Kapitel 1
C++ Lernen und professionell anwenden
Erstellen eines C++-Programms
Übersetzen eines C++-Programms
28
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Grundlagen
Zum Erstellen und Übersetzen eines C++-Programms sind folgende drei Schritte
notwendig:
1. Das C++-Programm wird mit einem Texteditor in eine Datei eingegeben.
Anders gesagt: Der Quellcode wird in einer Quelldatei abgelegt.
Bei größeren Projekten ist es üblich, modular zu programmieren. Dabei wird
der Quellcode auf mehrere Quelldateien verteilt, die getrennt bearbeitet und
übersetzt werden.
2. Die Quelldatei wird dem Compiler zur Übersetzung gegeben. Geht alles gut,
so erhält man eine Objektdatei, die den Maschinencode enthält. Eine Objektdatei heißt auch Modul.
3. Schließlich bindet der Linker die Objektdatei mit anderen Modulen zu einer
ausführbaren Datei. Die Module bestehen aus Funktionen der Standardbibliothek oder selbsterstellten, schon früher übersetzten Programmteilen.
Im Namen der Quelldateien muss die richtige Endung angegeben werden. Diese
hängt vom jeweiligen Compiler ab. Die gebräuchlichsten Endungen sind .cpp
und .cc.
Vor dem eigentlichen Kompiliervorgang können Header-Dateien, auch IncludeDateien genannt, in die Quelldatei kopiert werden. Header-Dateien sind Textdateien mit Informationen, die in verschiedenen Quelldateien gebraucht werden,
wie z.B. Typdefinitionen oder die Deklaration von Variablen und Funktionen.
Die Namen von Header-Dateien enden entweder mit .h oder haben keine
Endung.
Die C++-Standardbibliothek enthält fertige Funktionen und Klassen, die standardisiert sind und die jeder Compiler zur Verfügung stellt.
Moderne Compiler bieten eine integrierte Entwicklungsumgebung, die die obigen
drei Schritte zusammenfasst. Von einer einheitlichen Benutzeroberfläche aus
wird das Programm editiert, kompiliert, gelinkt und ausgeführt. Außerdem
können weitere Tools, wie z.B. ein Debugger, gestartet werden.
Wichtig: Enthält die Quelldatei auch nur einen Syntaxfehler, so zeigt dies der
Compiler mit einer Fehlermeldung an. Darüber hinaus können weitere Fehlermeldungen ausgegeben werden, die darauf beruhen, dass der Compiler versucht,
trotz des Fehlers weiter zu übersetzen. Beginnen Sie also immer mit der Korrektur des ersten Fehlers in einem Programm.
Neben den eigentlichen Fehlermeldungen gibt der Compiler auch Warnungen
aus. Eine Warnung zeigt keinen Syntaxfehler an, sondern ist lediglich ein Hinweis auf einen möglichen logischen Fehler, wie beispielsweise die Verwendung
einer nicht initialisierten Variablen.
29
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Kapitel 1
C++ Lernen und professionell anwenden
Ein erstes C++-Programm
Beispielprogramm
#include <iostream>
using namespace std;
int main()
{
cout << "Viel Spaß mit C++!"
return 0;
}
<<
endl;
Bildschirmausgabe
Viel Spaß mit C++!
Die Struktur der Funktion main()
30
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Grundlagen
Ein C++-Programm besteht aus Objekten mit ihren Elementfunktionen und aus
globalen Funktionen, die zu keiner Klasse gehören. Jede Funktion löst eine
bestimmte Aufgabe und kann andere Funktionen aufrufen. Sie ist entweder
selbsterstellt oder eine fertige Routine aus der Standardbibliothek. Die globale
Funktion main() muss immer selbst geschrieben werden und hat eine besondere Rolle: Sie bildet das Hauptprogramm.
Anhand des nebenstehenden kurzen Beispielprogramms lassen sich bereits die
wichtigsten Elemente eines C++-Programms erkennen. Das Programm enthält
nur die Funktion main() und gibt eine Meldung auf dem Bildschirm aus.
Die erste Zeile beginnt mit einem Doppelkreuz # und ist daher für den Präprozessor bestimmt. Der Präprozessor ist Teil der ersten Übersetzungsphase, in der
noch kein Objektcode erzeugt wird. Mit
#include <dateiname>
kopiert der Präprozessor die genannte Datei an diese Stelle in den Quellcode.
Dadurch stehen dem Programm alle Informationen zur Verfügung, die in dieser
Datei enthalten sind.
Die Header-Datei iostream enthält Vereinbarungen für die Ein-/Ausgabe mit
Streams. Der Begriff Stream (dt. Strom) spiegelt die Situation wider, dass Zeichenfolgen wie ein Datenstrom behandelt werden.
Die in C++ vordefinierten Namen befinden sich im Namensbereich std (standard). Die anschließende using-Direktive erlaubt, die Namen aus dem
Namensbereich (Namespace) std direkt zu verwenden.
Die Programmausführung beginnt mit der ersten Anweisung in der Funktion
main(), die daher in jedem C++-Programm vorhanden sein muss. Nebenstehend ist die Struktur der Funktion dargestellt. Sie unterscheidet sich, abgesehen
vom feststehenden Namen, nicht von der Struktur anderer Funktionen.
In unserem Beispiel enthält die Funktion main() zwei Anweisungen. Die erste
cout << "Viel Spaß mit C++!" << endl;
gibt den Text Viel Spaß mit C++! auf dem Bildschirm aus. Der Name cout
(console output) bezeichnet ein Objekt, das die Ausgabe durchführt.
Die beiden Kleiner-Zeichen << deuten an, dass die Zeichen in den Ausgabestrom „geschoben“ werden. Mit endl (end of line) wird anschließend ein Zeilenvorschub ausgelöst. Die zweite Anweisung
return 0;
beendet die Funktion main() und damit das Programm. Dabei wird der Wert 0
dem aufrufenden Programm als Exit-Code zurückgegeben. Es ist üblich, den
Exit-Code 0 zu verwenden, wenn das Programm korrekt abgelaufen ist.
Beachten Sie, dass die Anweisungen mit einem Semikolon enden. Die kürzeste
Anweisung besteht übrigens nur aus einem Semikolon und bewirkt nichts.
31
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Kapitel 1
C++ Lernen und professionell anwenden
Struktur einfacher C++-Programme
Ein C++-Programm mit mehreren Funktionen
/******************************************************
Ein Programm mit mehreren Funktionen und Kommentaren
******************************************************/
#include <iostream>
using namespace std;
void linie(), meldung();
// Prototypen
int main()
{
cout << "Hallo! Das Programm startet in main()."
<< endl;
linie();
meldung();
linie();
cout << "Jetzt am Ende von main()." << endl;
return 0;
}
void linie()
// Eine Linie ausgeben.
{
cout << "--------------------------------" << endl;
}
void meldung()
// Eine Meldung ausgeben.
{
cout << "In der Funktion meldung()." << endl;
}
Bildschirmausgabe
Hallo! Das Programm startet in main().
-----------------------------In der Funktion meldung().
-----------------------------Jetzt am Ende von main().
32
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Grundlagen
Das nebenstehende Beispiel zeigt, wie ein C++-Programm strukturiert ist, das
aus mehreren Funktionen besteht. Die Reihenfolge, in der Funktionen definiert
werden, ist in C++ nicht vorgeschrieben. Zum Beispiel könnte auch zuerst die
Funktion meldung(), dann die Funktion linie() und schließlich die mainFunktion geschrieben werden.
Üblicherweise wird die Funktion main() zuerst angegeben, da sie den Programmablauf steuert. Es werden also Funktionen aufgerufen, die erst später
definiert werden. Dies ist möglich, da der Compiler mit dem Prototyp einer
Funktion die notwendigen Informationen erhält.
Neu in diesem Beispiel sind die Kommentare. Jede Zeichenfolge, die durch
/* . . . */ eingeschlossen ist oder mit // beginnt, ist ein Kommentar.
Beispiele:
/* Ich darf mehrere Zeilen lang sein */
// Ich bin ein Einzeilen-Kommentar
Beim Einzeilen-Kommentar ignoriert der Compiler ab den Zeichen // alle Zeichen bis zum Zeilenende. Kommentare, die sich über mehrere Zeilen erstrecken,
sind bei der Fehlersuche nützlich, um ganze Programmteile auszublenden. Jede
der beiden Kommentarformen kann auch benutzt werden, um die andere auszukommentieren.
Zum Layout einer Quelldatei: Der Compiler bearbeitet jede Quelldatei sequenziell und zerlegt den Inhalt in „Token“ (kleinste Bestandteile), wie z.B. Funktionsnamen und Operatoren. Token können durch beliebig viele Zwischenraumzeichen getrennt sein, also durch Leer-, Tabulator- oder Newline-Zeichen. Es
kommt daher nur auf die Reihenfolge des Quellcodes an, nicht auf ein bestimmtes Layout, wie etwa die Aufteilung in Zeilen und Spalten. Beispielsweise ist
void meldung
(
){ cout <<
"In der Funktion meldung()." <<
endl;}
zwar eine schlecht lesbare, aber korrekte Definition der Funktion meldung().
Eine Ausnahme hinsichtlich des Layouts bilden die Präprozessor-Direktiven,
die stets eine eigene Zeile einnehmen. Dem Doppelkreuz # zu Beginn einer Zeile
dürfen nur Leer- und Tabulatorzeichen vorangehen.
Zur besseren Lesbarkeit von C++-Programmen ist es von Vorteil, einen einheitlichen Stil in der Darstellung beizubehalten. Dabei sollten Einrückungen und
Leerzeilen gemäß der Programmstruktur eingefügt werden. Außerdem ist eine
großzügige Kommentierung wichtig.
33
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Kapitel 1
C++ Lernen und professionell anwenden
Übungen
Programm-Listing zur 3. Aufgabe
#include <iostream>
using namespace std;
void pause();
// Prototyp
int main()
{
cout << endl << "Lieber Leser, "
<< endl << "goennen Sie"
<< " sich jetzt eine ";
pause();
cout << "!" << endl;
return 0;
}
void pause()
{
cout << "PAUSE";
}
34
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Grundlagen
1. Aufgabe
Erstellen Sie ein C++-Programm, das den folgenden Text auf dem Bildschirm
ausgibt:
Moegen
taeten wir schon wollen,
aber koennen
haben wir uns nicht getraut!
Verwenden Sie den Manipulator endl an den entsprechenden Stellen.
2. Aufgabe
Das folgende Programm enthält lauter Fehler:
*/ Hier sollte man die Brille nicht vergessen //
#include <stream>
int main
{
cout << "Wenn dieser Text",
cout >> " auf Ihrem Bildschirm erscheint, ";
cout << " endl;"
cout << 'können Sie sich auf die Schulter '
<< "klopfen!" << endl.
return 0;
)
Korrigieren Sie die Fehler, und testen Sie die Lauffähigkeit des Programms.
3. Aufgabe
Was gibt das nebenstehende C++-Programm auf dem Bildschirm aus?
35
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Kapitel 1
C++ Lernen und professionell anwenden
Lösungen
Zur 1. Aufgabe:
// Auf geht's !
#include <iostream>
using namespace std;
int main()
{
cout <<
cout <<
cout <<
cout <<
"Moegen " << endl;
"taeten wir schon wollen" << endl;
"aber koennen " << endl;
"haben wir uns nicht getraut!" << endl;
return 0;
}
Zur 2. Aufgabe:
Die korrigierten Stellen sind unterstrichen.
/* Hier sollte man die Brille nicht vergessen */
#include <iostream>
using namespace std;
int main()
{
cout << "Wenn dieser Text";
cout << " auf Ihrem Bildschirm erscheint, ";
cout << endl;
cout << "können Sie sich auf die Schulter "
<< "klopfen!" << endl;
return 0;
}
Zur 3. Aufgabe:
Die Bildschirmausgabe des Programms beginnt in einer neuen Zeile:
Lieber Leser,
goennen Sie sich jetzt eine PAUSE!
36
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Stichwortverzeichnis
A
Abbau
dynamischer Objekte
589
von Objekten 297
Ableitung
mehrfache 629
abs() 941, 951
Absolutwert 131, 963
abstrakt
Klasse 609
Abstraktion
durch Klassen 269
acos() 951
Adapterklasse 805
Addition
von Zeigern 381
Adresse 256
des aktuellen Objekts
309
Übergabe 249
Vektor 385
von Objekten 255, 279
von Zeigern 255
Adressoperator 442
Adressraum
von Hash-Dateien 698
Änderungsfreundlichkeit
143
Aktualisieren
von Dateien 415
algorithm 70
Algorithmus 909
binäre Suche 697, 812
Bresenham- 789
Bubble-Sort- 363
Heap-Sort- 933
Hot-Potatoe 835
Misch- 497
Mischen 814
modifizierender 925
mutierender 929
Quick-Sort- 729, 739
Selection-Sort- 397, 723,
739
Sieb des Eratosthenes
363
Splice- 497
Aliasname 247
allocate_shared() 861
allocator 805
Allokator-Klasse 805
Alternative
auswählen 133
Ampersand 247
Analyse 269
Anfangswert 53, 73, 291
eines Objekts 293
von Objekten 275
Ansi.sys 979
ANSI-Komitee 25
Anweisung 31
abhängige 119
break 133, 135
continue 135
goto- 135
if else 127
return() 199
switch 133
throw 651
Anwenderprogramm
Quellcode 273
app 414
Applikation 881
apply() 951
arg() 941
argc 395
argptr 725
Argument 65, 197, 199
Kommandozeilen- 395
komplexes 937
Objekt als 311
obligatorisches 725
optionales 725
Typumwandlung 169
-Übergabe 201
variable Anzahl 725
Vektor als 385
-Zeiger 725
Zeigervektor 723
argv 395
Arithmetik
mit Zeigern 381, 383
Array 351
assoziativer 457
-Klasse 456
Klassen- 357
ASCII-Code 39
Tabelle 977
asin() 951
assert.h 70
assoziativ
Array 457
Container 803
Asynchronous Transfer
Mode 759
at() 187, 813
atan() 62, 951
atan2() 62, 951
ate 414
ATM-Zelle 759
Auflösung 787
Aufruf
Exception-Handler 655
Funktions- 199
impliziter 297
redefinierter Methoden
551
von Destruktoren 297,
549
von Funktionen 65
von Konstruktoren 549
Aufzählung 337
Ausdruck 105
boolescher 45
komplexer 105
logischer 113
mit Referenztyp 253
Typ 105
Vergleichs- 111
Wert 105
Ausgabe 31, 80
dezimale 85
hexadezimale 85
linksbündig 89
oktale 85
rechtsbündig 89
1003
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Stichwortverzeichnis
-Strom 83
umlenken 153
unformatierte 97
von booleschen Werten
91
von Strings 91
von Zeichen 91
Ausgabefeld 89
Ausnahmebehandlung 651
schachteln 657
Ausrichtung 89
byteweise 970
Auswahl 127, 133
Auswahloperator 131
auto 211, 229
auto_ptr 850
automatisch 223
AVL-Baum 821
B
back() 813
Backslash 49
Backspace 93
bad() 685
bad_cast 593
Basis 93, 964
Basisinitialisierer 549, 635
bei Mehrfachvererbung
637
Basisklasse 539
direkte 541
indirekte 541
mehrfache 633
mehrfache indirekte 631
virtuelle 633
Basisklassenzeiger 575
Basistyp 255
Baum 695
AVL- 821
Rot-Schwarz- 821
Baumstruktur 803
bedingt
Bewertung 131
Kompilierung 149
Bedingung
zusammengesetzte 113
Bedingungsvariable 893
begin() 807, 833
Begrenzungszeichen 97
Belegungsfaktor 829
BELL 125
Benutzeroberfläche 29
Bereich
capture 915
Iteratoren- 909
private 271
public 271
Bereichsoperator 233, 273,
333
Bereichsprüfung 187, 291,
301
Bewertung
bedingte 131
-Reihenfolge 113
Bezeichner 63, 233
Read-Only 247
Beziehung
Hat- 539
Ist- 539
Bias 964
Bibliothek 195
iostream- 81
numerische 935
bidirektional
Iterator 807
Bildschirm
Steuerzeichen 145, 979
-Treiber 979
binär 962
Binärmodus 419, 679
binär
Suche 933
binary 414
Bindung
dynamische 591
späte 591
statische 591
Bit
-Codierung 751
eof- 415
fail- 415
-Feld 759
invertieren 755, 789
löschen 755, 789
Maske 755
-Muster 85, 164, 755,
962, 964
-Operation 751
-Operator 751, 789
Paritäts- 757
Schreiben 789
-Set 787
setzen 755, 789
Vorzeichen- 962
Bitoperator 415
bitset 70
Block 119, 227
catch 653
einer Funktion 197
extern 972
try- 653
blockorientiert 409
blockweise
Schreiben/Lesen 419
bool 39
boolalpha 91
break
Anweisung 133, 135
Breite
eines Bitfelds 759
Bresenham-Algorithmus
789
Bruch
kürzen 479
Rechenoperationen 460
Bubble-Sort 363
Buchstabe
umwandeln 151
Bucket 829
Byte 41
Ausrichtung 970
-Offset in Dateien 681
-Position 409
C
C
-Bibliotheken einbinden
972
-Funktion definieren
973
-Funktion einbinden 972
-Header-Datei 71, 972
-String 71
C++
-Programm 29
-Standardbibliothek 73,
195
call by reference 201, 249,
311
call by value 201, 249, 311
case
Konstante 133
Marke 133
1004
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Stichwortverzeichnis
Cast
Down- 593
dynamischer 593
expliziter 577
-Operator 169, 577
statischer 577
Up- 577
catch 653
cctype 151
cerr 80
cfloat 43, 964
char 39, 91
-Vektoren 355
CHAR_MAX 41
CHAR_MIN 41
char16_t 39
char32_t 39
cin 80, 253
class 271, 281
clear() 92, 685, 817
Client 897
climits 41, 964
clog 80
close() 417
cmath 63
Code
von Funktionen 147
Comparator
-Klasse 805
Compare 805
Compiler 29
Compilierung
bedingte 967
complex 70, 939
COMSPEC 398
condition_variable 893
conio.h 154
conj() 943
const 55, 249
Methode 303
-Objekt 303
const_iterator 807, 833
Container
Arten 803
-Bibliothek 803
Kapazität 815
-Klasse 805
-Länge 815
Löschen 817
sequenziell 803
ungeordneter 829
vereinbaren 809
Zugriff 813
continue
-Anweisung 135
Cooked Modus 414
copy() 925
cos() 62, 943
cosh() 943
count() 825
cout 31, 80, 253
cshift() 951
cstdlib 67
C-String 355
ctime() 189
ctype.h 70, 151
Cursor 787
D
Darstellung
binäre 962, 963
dezimale 85
exponentielle 87
Festpunkt- 87
-Format 962
interne von Daten 269
von Ganzzahlen 962
von Gleitpunktzahlen
964
Datei 409
aktuelle Position 409
-Anfang 681
ausführbare 29, 195
-Ende 415, 681
Geräte- 683
Hash- 698
Index- 693
kopieren 417
lesen 409
-Name 413
öffnen 413
Pizza- 423
Primär- 693
-Puffer 409
schließen 417
schreiben 409
-Status 685
umlenken 153
-Zugriff 409
Dateiende 150
Dateiposition
ändern 679
Daten
verschlüsseln 761
Datenabstraktion 25, 539
Datenelement 73
abgeleiteter Klassen 543
dynamisches 509
konstantes 331
Speicherplatz 273
statisches 333
variabler Länge 509
von Klassen 269
Datenkapselung 25, 269,
281, 335, 455
Datenkommunikation 835
Datensatz 281, 409
Datensegment 227
Datenstruktur
dynamische 493
rekursive 495
Datentyp 39
bool 39
char 39
const_iterator 807
double 43
elementarer 39
float 43
ganzzahliger 41
-Hierarchie 163
int 41
ios 681
iostate 685
Klasse 269
long 41
long double 43
short 41
time_t 285
void 43, 67, 199
von Variablen 53
wchar_t 39
Datenübertragung
Fehlererkennung 757
Datum 285, 317
Deadlock 891
dec 84
Default
Argumente von Funktionen 205
-Konstruktor 293
default
-Marke 133
default_delete 851
1005
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Stichwortverzeichnis
defined 968
Definition
abgeleitete Klasse 540
Funktion 197
inline 203
rekursiver Funktionen
209
typedef 733
virtueller Methoden 587
von File-Streams 413
von Klassen 271
von Konstruktoren 291
von Methoden 273
von Objekten 275
von Referenzen 247
von Typnamen 733
von Variablen 53
von Vektoren 351
Deklaration
Exception 653
extern- 225, 972
friend- 455
komplexe 731
protected 553
using- 235
von Funktionen 63
von Konstruktoren 291
von Variablen 225
Dekrement
-Operator 107
delete 487, 489, 589
Deleter 855, 861
selbstdefiniert 861
deque 805
dequeue 70
Design
von Klassenhierarchien
633
Destruktor 297
abgeleiteter Klassen 549
Aufruf 297
Default- 297
für Vektorklasse 513
inline 299
Minimalversion 297
virtueller 589
detach() 889
dezimal 45
Dezimalpunkt 86
Diagramm
Vererbungs- 631, 635
Dimension
von Vektoren 359
Direktive 31, 965
#define 143, 147
#elif 967
#endif 149, 967
#error 970
#if 967
#ifdef 149, 969
#ifndef 149
#include 63, 967
#line 969
#pragma 970
#undef 149, 966
using 71, 235
Division 105
ganzzahlige 105
mit Zweier-Potenzen
753
domain_error 660
Doppelpunkt 135
DOS 153
double 43
do-while
-Schleife 125
Down-Cast 577
Download 980
draw() 787
Dreiecksmatrix 959
dynamic_cast<> 593
dynamisch
Bindung 591
Datenelement 509
Datenstruktur 493
Matrix 737
Speicherreservierung
485
E
Einbinden
von C-Funktionen 972
Einfügen
in Containern 811
in Index-Datei 695
in Strings 183
in Maps 825
Eingabe 80
fehlerhafte 95
-Feld 93
formatierte 92
-Puffer 93
Textzeile 97
umlenken 153
unformatierte 97
von Gleitpunktzahlen
95
von Zahlen 94
Eingabepuffer
löschen 92
Einheit
imaginäre 937
Einheitswurzel
komlexe 953
Einlesen Siehe Eingabe
Einmaleins 137
Element
abgeleiteter Klassen 543
dynamisches 509
eines Vektors 351
-Zugriff 271
elementar
Operation 493
Elementfunktion 31, 73, 269
statische 335
Elementinitialisierer 329,
549
else
-Zweig 127
else-if
-Kette 129
emplace() 811, 823
empty() 815
end() 807, 833
endl 83
Endlosschleife 123
Entpacken
rekursiv 785
Entwicklungsumgebung
integrierte 29, 212, 273
enum 337
env 404
Environment 399
eof() 415, 685
erase() 183, 817, 823
Eratosthenes
Sieb des 363
Eröffnungsmodus
-Flag 415
für Dateien 413
errno.h 70
Ersatztext 143, 965
Ersetzen
in Strings 185
1006
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Stichwortverzeichnis
Erweiterung 145
Ganzzahl- 163, 753
Null- 165
Vorzeichen- 165
ESC 979
Escape-Sequenz 49, 145
Euler 943
Exception 187
auffangen 653
auslösen 651
bad_cast 593
-Deklaration 653
-Handler 653
-Handler genereller 655
-Handling 651
-Handling für Dateien
687
-Spezifikation 657
exception 70
exceptions() 687
exit() 417
Exit-Code 31
Exklusiv ODER 751
exp() 62, 943, 951
explicit 477
explizit
Cast 577
inline 299
Exponent 214, 964
Exponentialdarstellung
komplexer Zahlen 943
exponentiell
Darstellung 87
extend
sign- 165
zero- 165
extern 231
Speicherklasse 225
F
fail() 415, 685
failbit 415
Fakultät 213
false 39, 111
Fehler
-Behandlung traditionelle 649
-Code 417
-Flag 649
-Meldung 393
-Nummer 393
-Objekt 651
-Situation 649
-Variable 649
Fehlerbehandlung
für Dateien 415
für new 487
Fehlererkennung
bei Datenübertragung
757
Fehlerflag 95
Fehlerklasse 651
bad_cast 593
definieren 659
domain_error 660
exception 661
invalid_argument 660
length_error 660
logic_error 661
out_of_range 813
overflow_error 660
range_error 660
runtime_error 661
underflow_error 660
Fehlermeldung 29, 65, 303
des Präprozessors 970
Feld
Bit- 759
Feldbreite 85, 89, 93
Festplatte 409
Festpunktdarstellung 87
Festpunktzahl 86
Fibonacci
-Quotient 353
-Zahl 353
FIFO-Prinzip 803
File-Stream
Definition 413
-Klassen 411
fill() 88
Filterprogramm 151, 153
finale Klasse 541
finale Methoden 586
find() 185, 825, 921
first 825
fixed 86
Flag 45, 415
Eröffnungsmodus- 414
Fehler- 649
ios 685
Positionierungs- 681
Status- 415, 685
von ios 83
flip() 789
float 43
float.h 70
floating point types 42
for
-Schleife 121
for_each() 913, 921
Form
normalisierte 964
Format
IEEE- 964
Formatierung 83
Formel
Eulersche 943
Forward-Iterator 917
Fourier-Transformierte 953
Freispeicher 485
Freund 455
friend
-Deklaration 455
-Funktion 453
-Klasse 455
-Konzept 453
front() 813
fstream 70, 411
Füllzeichen 89
functional 70
Funktion
Aufruf 65, 199
Block 197
definieren 197
Deklaration 199
externe 231
friend- 453
globale 31, 195, 311
Hash- 698, 829
inline- 203
inverse trigonometrische 951
Kopf 197
main() 31
Merge- 497
Name 197
Operator 445
Prototyp 197
rekursive 209
Return-Wert 199
Signatur 207
Speicherklasse 231
Splice- 497
static- 231
1007
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Stichwortverzeichnis
transzendente 943
trigonometrische 943
Typ 197
überladen 207
Version 205
Zeigerversion 387
Funktionsobjekt 911
vordefiniertes 913
G
Ganzzahl 962
-Erweiterung 163, 753
positive 962
Geltungsbereich
global 225
von Variablen 223
Genauigkeit 43, 87, 964
Generator
Programm 969
Gerade
zeichnen 789
Geschwindigkeit 129
vergleichen 739
get() 97
get_id() 889
getch() 154
getline() 73, 97, 177, 421
Gleichung
quadratische 260
Gleitpunktdarstellung 43
Gleitpunktdivision 443
Gleitpunktkonstante 47
Gleitpunkttyp 43
Gleitpunktzahl 43, 47, 87
interne Darstellung 964
global
Funktion 195
Variable 53
Vektor 353
good() 685
goto
-Anweisung 135
Grad 945
Großbuchstabe 151
H
Handler
Exception- 653
Hash
Datei 698
Funktion 698
Hashfunktion 829
Hash-Tabelle 803, 829
Hat-Beziehung 327, 539
Hauptwert
komplexe Zahl 937
Logarithmus 943
Header
von ATM-Zellen 758
Header-Datei 29, 69, 147,
149, 273, 964
C- 972
cctype 151
cfloat 43, 964
climits 41, 964
complex 939
conio.h 154
cstdlib 67
ctype.h 151
deque 804
fstream 411
iostream 31, 69
list 804
map 820
memory 850
queue 804
set 820
stack 804
stdlib.h 67
string 71, 177
Suche nach 967
valarray 945
vector 804
Heap 485, 933
Heap-Sort-Algorithmus 933
hex 84
hexadezimal 45, 85
Hierarchie
der Fehlerklassen 661
von Datentypen 163
high
value 172
Horner-Schema 947
Hot-Potato-Algorithmus
835
HUGE_VAL 214
Hyperbelfunktion 943
I
Identifier 63
IEEE 42
IEEE-Format 964
if-else-Anweisung 127
ifstream 411
imag() 941
imaginär
Einheit 937
Imaginärteil 937
Implementierung
von Klassen 301
implizit
inline 299
Typanpassung 163
in 414
INCLUDE 967
Include-Datei 29
include-Verzeichnis 69
Index 187, 683
-Datei 693
-Operator 187, 813
-Operator für Vektorklasse 515
-Operator überladen
457
-Überprüfung 187
unzulässiger 187
Vektor- 351
-Version 387
Indizierung
indirekte 959
maskierte 959
selektive 953
Inhalt
von Unions 283
inhomogen
Liste 615
Initialisierung
- direkte 295
explizite 489
-Liste 299
mit Konstruktoren 291
statischer Objekte 227
Vektor 353
vereinheitlichte 827
virtueller Basisklassen
637
von const-Objekten 303
von Datensätzen 281
von Klassen-Arrays 357
von Objekten 293
von Referenzen 247
von Strings 177
von Teilobjekten 329
von Variablen 53
1008
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Stichwortverzeichnis
Initialisierungsliste 827
Inititialisierung
von Objekten 275
von Schleifen 121
Inkonsistenz
Betriebsmittel 887
Inkrement
-Operator 107
inline 203
-Methoden 299
input() 727
insert() 183, 810, 823
Insert-Iterator 919
Instanz 73
von Klassen 275
int 41
INT_MAX 41
INT_MIN 41
integral
promotion 163
integral types 42
Interface
polymorphes 611
internal 88
Interpretation
von Bitmustern 165
invalid_argument 660
Invertieren
von Bits 755
von Listen 819
iomanip 70, 87
ios 70, 81, 83, 414
ios::badbit 685
ios::beg 681
ios::cur 681
ios::end 681
ios::eofbit 685
ios::failbit 685
ios::goodbit 685
ios::seekdir 681
iosfwd 70
iostate 685
iostream 31, 69, 70, 81
is_open() 417
isalnum() 150
isalpha() 150
isdigit() 150
islower() 150, 151
iso646.h 70
isprint() 150
isspace() 150
Ist-Beziehung 539
istream 70, 81
isupper() 150
Iterator 807, 917
bidirektionaler 807, 917
Forward 917
Input 917
Insert 919
Output 917
Random-Access 807,
917
Stream 917
iterator 70, 807, 833
J
join() 883
K
kbhit() 154
Kellerstapel 803
Kette
else-if- 129
Key to Address Transformation 698
Klammern 145
Klasse
complex 939
finale 541
gslice 955
HashEntry 699
HashFile 699
Index 685
IndexEntry 683
IndexFile 695
KontoFile 691
Polynom 945, 947
slice 953
thread 883
valarray 945
VekQueue<T> 835
Klasse Siehe auch Standardklasse 445
abgeleitete 539
abstrakte 609
Adapter- 805
Ampel 337, 341
Angestellter 611
Arbeiter 609
Array- 456
Artikel 315, 339
Basis- 539
Cell 615
Comparator 805
Container 805
Datum 285, 317
DayTime 445
Definition 271
Euro 447
File-Stream- 411
FloatVek 456, 509, 527
Fraction 461
friend- 455
für Brüche 461
für Vektoren 457
GiroKonto 557
InhomList 617
iostream 81
istream 81
Kfz 539, 543
Kombi 633
konkrete 609
Konto 271, 421
Konzept 269
Liste 495
Lkw 557
Matrix 737
mehrfach abgeleitete
629
MessStation 454
Messwert 327, 454
Mitarbeiter 607
Mitglied 339
ostream 81
PackedFood 559
Pkw 543
polymorphe 585
Product 559
sortVec 809
SparKonto 557
StadtAuto 595
Standard- 73
TelList 361, 365, 425
Transporter 641
Typumwandlung 473
UnpackedFood 559
Wohnwagen 639
Zeile 737
zur Darstellung von
Vektoren 361
1009
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Stichwortverzeichnis
Klassen-Array 357
Klassenhierarchie
Design 633
Typumwandlung 571
Klassenvariable 333
Kleinbuchstabe 151
Koeffizient 945
Kollision
beim Hashing 698
Kommando 153
-Interpreter 417
-Zeile 212
Kommandozeile
Argumente 395
Kommaoperator 123, 442
Kommentar 33
Kompatibilität
zu C 281
Kompilierung
bedingte 149
Komplement
Zweier- 963
komplex
Deklaration 731
konkret 609
Konstante 45
boolesche 45
case- 133
enum- 337
Gleitpunkt- 47
klassenspezifische 337
numerische 45
String- 47
symbolische 141, 143,
965
Zeichen- 47
Konstruktor 291
abgeleiteter Klassen 549
Aufruf 293
Default- 293
Definition 291
Delegation 295
explicit 477
für Vektorklasse 513
inline- 299
Kopier- 305, 517
Minimalversion 293
Move- 521
überladen 291
Konto 271
Kontrollblock 857
Konvention
Namens- 271
Konvertierung
für Klassen 473
-Funktion 473
in Basisklasse 571
-Konstruktoren 472
von Argumenten 169
von Ganzzahlen 165
von Referenzen 575
von Smart Pointern 859
von Zeigern 575
Kopie
Rückgabe 313
von Objekten 311
Kopier-Konstruktor 305,
517
Kürzen
von Brüchen 479
L
Länge
von Strings 73, 177
von Vektoren 385
Lambda
-Ausdruck 914
-Funktionen 914
Länge
numerischer Vektor 945
Laufbedingung 119
Laufzeit 203, 299
Layout 129
ldexp() 62
Lebensdauer
automatisch 223
statisch 223, 227
von Variablen 223
left 88
length() 73, 177
length_error 660
Lesbarkeit 143
Lesen
aus Dateien 409
blockweises 419
less 805
lexikografisch 181
LIFO-Prinzip 201, 803
limits 70
limits.h 70
linear
Lösung beim Hashing
698
Linearisierung 955
Linker 29, 195
linksbündig 89
list 70, 805
Liste 527
Container 805
doppelt verkettete 805
einfach verkettete 493
einfügen 617
für Vektorelemente 353
inhomogene 615, 859
Initialisierungs- 281
invertieren 819
mischen 819
Operationen 819
Parameter 197
sortieren 819
verschweißen 819
von Elementinitialisierern 329
von Exceptions 657
Listenelement 493
Literal 45
load factor 829
locale 70
locale.h 70
localtime() 285
lock() 887
lock_guard 891
Löschen
in Containern 817
in Sets 823
in Strings 183
von Bits 755
Lösung
lineare, beim Hashing
698
log() 62, 943, 951
log10() 62, 943, 951
lokal 201, 223
Variable 53
Vektor 353
long 41
long double 43
long long 41
L-Wert 257
M
main() 197
Parameter 395
make_heap() 933
1010
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Stichwortverzeichnis
make_shared() 861
MAKE-Utility 195
Makro 141, 143, 965
__cplusplus 971
__DATE__ 971
__FILE__ 971
__LINE__ 971
__STDC__ 971
__TIME__ 971
isalnum() 150
isalpha() 150
isdigit() 150
islower() 150, 151
isprint() 150
isspace() 150
isupper() 150, 151
mit Parametern 145
-Namen 143
tolower() 151
toupper() 151
va_end() 727
va_start() 725
Mandelbrot-Menge 940
Manipulation
von Bits 789
Manipulator 83
Mantisse 964
Map 803
Einfügen 825
ungeordnete 831
vereinbaren 825
map 70, 820
Marke 135
case- 133
default- 133
private 271
public 271
maschinenabhängig 964
Maschinencode 29, 197
von Methoden 275
Maschinenregister 41
Maske
Bit- 755
Massenspeicher 409
math.h 70, 214
Matrix 359, 955
dynamische 737
max() 951
max_size() 815
Mehrdeutigkeit
bei Mehrfachvererbung
631
bei Typumwandlungen
207, 477
Mehrfachvererbung 629
member 271
memory 70, 850
Menüauswahl 133
merge() 497, 819, 931
Methode 73, 269
Definition 273
Dummy- 607
finale 586
inline 299
Read-Only- 303
Standard- 305
statische 335
virtuelle 585
virtuelle definieren 587
min() 951
Minor 957
Mischen
von Listen 819
von Vektoren 497
Modifizierer 41
Modul 29, 195, 223, 273
modulglobal 223, 227
Funktion 231
Modulo
-Division 105
Modus
Binär- 419
Cooked 414
Raw 414
update- 415
move() 787
Move-Konstruktor 521
Move-Zuweisung 525
Multimap 820, 821, 825
ungeordnete 831
Multiplikation
mit Zweier-Potenzen
753
Multiset 820, 823
ungeordnetes 831
Mutex 887
rekursiv 891
N
Name 51, 233
Deklaration von 63
Funktion 197, 729
Regeln für die Vergabe
271
Suche 545
verdecken 547
von Bitfeldern 759
von Klassen 271
von Konstruktoren 291
von Makros 143
von Vektoren 351, 379
Namensbereich 71, 223, 233
Namenskonflikt 71, 233
namespace 71, 233
new 70, 485
New-Handler 487
Newline 73
NICHT 751
NICHT-Operator 113
noboolalpha 91
Norm
komplexer Zahl 943
norm() 943
noshowpoint 86
noshowpos 84
Not-any-thread 889
Notation
exponentielle 87
Postfix 107
Präfix- 107
notify_one() 895
nouppercase 84
NULL 256
Null-Erweiterung 165
numeric 70
numeric_limits 964
O
Objekt 27, 53, 73
Abbau 297, 589
abgeleiteter Klassen 551
Adresse 309
als Argument 311
als Return-Wert 313
auto- 229
const- 303
Definition 275
degeneriertes 955
Eigenschaften 269
Fähigkeiten 269
global 223
in Datei speichern 421
konstant 55
1011
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Stichwortverzeichnis
lokal 201, 223
modulglobal 223, 227
Name 225
persistent 689
Persistenz 421
Read-Only- 55
statisches 227
Typ 225
-Übergabe 311
Zeiger auf 279
zuweisen 277
Objektdatei 29
Objektsammlung 803
obligatorisch
Argument 725
oct 84
ODER 751
exklusiv 750, 751
ODER-Operator 113
öffentlich 73
Schnittstelle 543, 555
Öffnen
von Dateien 413
ofstream 411
oktal 45
OOP Siehe Programmierung, objektorientierte
open() 413
openmode 414
Operand 105
symmetrischer 449
Operation 105
elementare 493
für Container 803
für Listen 819
Invertieren 819
Mischen 819
Splice- 819
Operator 233, 273
939
- 107, 939
-- 107
! 113
!= 111, 939
# 965
## 966
% 939
& 751
&& 113
() 169
* 257, 939
*= 947
+ 107, 179, 939
++ 107
+= 179, 947
, 123
. 277
/ 939
/= 947
:: 273, 333
< 111
<< 81, 253, 751
<= 111
-= 947
= 109, 277
== 111, 939
-> 279
> 111
>= 111
>> 81, 177, 253, 751, 939
? 131
^ 751
| 415, 751
|| 113
~ 751
arithmetischer 105
Auswahl- 131
Bereichs- 273, 333
binärer 105
Bit- 751
boolescher 113
Cast 169, 577
defined 968
Dekrement- 107
delete 487, 489
dynamic_cast<> 593
-Funktion 445
-Funktion als Methode
449
Funktion globale 451
Funktion virtuelle 613
Index- 187, 813
Inkrement- 107
Komma- 123
logischer 113
logischer Bit- 751
mit Referenztyp 253
new 485, 489
NICHT 113, 751
nicht überladbarer 443
ODER 113, 751
Pfeil- 279
Punkt- 277
Shift- 751, 753
Shift- überladen 459
sizeof 43
überladbarer 442
-Überladung 442
unärer 105
unärer arithmetischer
106
UND 113, 751
Vergleichs- 111
Verweis- 257
virtueller 613
Vorzeichen 107
Zuweisungs- 109, 277,
519
operator-() 452
operator*() 452
operator+() 452
operator+=() 446
operator/() 452
operator<<() 458, 459
operator-=() 446
operator>>() 458
Operatoren
Übersicht 974
Vorrangtabelle 976
optional
Argument 725
ostream 70, 81
out 414
out_of_range 660, 813
Output-Iterator 917
overflow_error 660
Overhead 299
overloading 207, 443
override 586
P
Paar
Schlüssel-/Objekt- 825
pair 825
Palindrom 189
Parameter 197
aus Kommandozeile
395
-Liste 197
mehrdimensionaler
Vektor 387
-Pack 785
Read-Only-Zeiger 389
1012
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Stichwortverzeichnis
Typumwandlung 169
variable Anzahl 725, 785
von main() 395
von Makros 145
Zeiger 259
Paritätsbit 757
Passwort 227
past token 966
PATH 398
-Variable 153
payload 759
Performance
-Test 739
Persistenz 409
polymorpher Objekte
689
von Objekten 421
Pfadangabe 967
Pfeiloperator 279
PI 143
picture element 787
Pixel 787
Pizza 423
Platzhalter 145
Pointer 255
Smart- 847
polar() 941
Polarkoordinaten 937, 941
polymorph
Schnittstelle 611
Polymorphie 25, 585
Polynom 945
Produkt 949
Summe 949
pop_back() 817
pop_front() 817
Position
Byte- 409
Cursor- 787
in Containern 807
in Strings 183
Positionierung
-Flag 681
wahlfrei 681
Postfix
-Notation 107
-Operator überladen
460
Potenz 214, 943
Potenzdarstellung
von Ganzzahlen 962
Potenzreihe 942
pow() 62, 65, 214, 943, 951
Prädikat 913
Präfix
-Notation 107
-Operator überladen
460
Präprozessor 31, 965
-Direktiven 33
Fehlermeldung 970
precision 86
Primärdatei 693
Primzahl 363
Prinzip
FIFO- 803
LIFO- 201, 803
Priorität
arithmetischer Operatoren 107
Warteschlange 805
priority_queue 805
private 271
Vererbung 541, 629
Problem
Producer-Consumer
893
Reader-Writer 899
Producer-Consumer
Problem 893
Programm
Anwendungs- 269
beenden 417
-Code 203
-Generator 969
-Struktur 33
-Umgebung 399
programmglobal 223
Programmierung
modulare 29, 273
objektorientierte 27, 269
prozedurale 27
Projekt 195, 212, 273
Software- 147
promotion
integral 163
PROMPT 398
protected 553
-Vererbung 541, 629
Prototyp 33, 63
-Funktions- 197
Prozess
aufrufender 417
PSEUDO 365
public 271
interface 271
Vererbung 629
Puffer 355
Punkt 73
Punktoperator 277
push() 811
push_back() 810
push_front() 810
put() 97
Q
qsort() 729, 738
quadratisch
Gleichung 260
Quadratwurzel 943
Quellcode 29
Quelldatei 29, 195, 273
Layout 33
Queue 803, 804
double ended 805
queue 70
Quick-Sort 729
R
rand() 67
Random Access 679
Random-Access
Iterator 807
Random-Access-Iterator
917
range_error 660
Range-For-Schleife 827
Rastergrafik 787
Raw Modus 414
rdstate() 685
read() 419
Reader-Writer
Problem 899
Read-Only 247
-Methode 303
-Referenz 251
-Zeiger 389
real() 941
Realteil 937
Rechenregeln 105
rechtsbündig 89
record 281
recursive_mutex 891
Redefinition
1013
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Stichwortverzeichnis
virtueller Methoden 587
von Datenelementen
547
von Elementen 543
von Methoden 547
Referenz 247
als Parameter 249
als Return-Wert 251, 313
auf abstrakte Klassen
611
auf Konstante 247
auf R-Wert 523
Read-Only- 247, 251
-Typ 249
Referenztyp
bei Operatoren 253
Referenzzähler 857
Register 229
Reihenfolge
von Destruktor-Aufrufen 589
von Konstruktor-Aufrufen 327, 549, 635
rein virtuell 607
Reinitialisierung 121
Rekonstruktion
von Objekten 421
rekursiv
Datenstruktur 495
Funktion 209
release() 853
remove() 927
replace() 185, 927
reset() 789, 853
resize() 815, 945
Return
-Taste 73
return() 31, 199
Return-Typ
-Ableitung 211
nachgestellter 211
Return-Wert 63, 199, 313
Objekt als 313
reverse() 385, 819
Reverse-Iterator 919
rfind() 185
right 88
Ring-Shift 951
Rot-Schwarz-Baum 821
Router 835
Routing
Verfahren 835
RTTI 592
Rücksprungadresse 203
Run-Time-Type-Information 592
R-Wert 257
bewegen 523
Referenz auf 523
S
Schachteln
von Ausnahmebehandlungen 657
Schalter 45
Schaltjahr 316
Schleife 119
do-while- 125
Endlos- 123
Kopf 121
Range-For 827
schachteln 125
Zähler 121
Schlüssel
/Objekt-Paar 825
bei Hash-Dateien 698
eingebetteter 821
Schlüsselwort 51
const 55
volatile 55
Schnittstelle
Funktions- 197
öffentliche 271, 543, 555
polymorphe 611
public- 543, 555
von Klassen 301
Schreiben
blockweises 419
in eine Datei 409
Schreibschutz
für Parameter 389
Schreibweise
exponentielle 47
Schrittweite 953
scientific 86
search() 923
second 825
seekg() 681
seekp() 681
Seiteneffekt 109, 147
Selbstaufruf
von Funktionen 209
Selection-Sort-Algorithmus
397, 723
Semikolon 31
sequences 803
sequenziell
Container 803
Dateizugriff 409
Server 897
Set 803
Einfügen 823
Löschen 823
ungeordnetes 831
vereinbaren 823
set 70, 820, 831
set() 789
setf() 82
setfill() 88
setjmp.h 70
setprecision() 86
setw() 88, 355
Setzen
von Bits 755
shared_ptr 850, 857
Shell 417
Shift
arithmetischer 753
Links- 753
logischer 753
-Operator 753
-Operator überladen
459
Rechts- 753
shift() 951
short 41
showpoint 86
showpos 84
Sieb
Eratosthenes- 363
sign
extend 165
signal.h 70
Signatur
virtueller Methoden 587
von Funktionen 207
von Konstruktoren 291
sin() 62, 943
sinh() 943
size() 177, 815, 945, 957
sizeof 43
sizeof() 283
Skalar 941, 947
1014
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Stichwortverzeichnis
sleep() 340, 885
slot 681, 698
Smart Pointer 847
vergleichen 855
Software
-Komponenten 195
-Projekt 147
Sondertasten 154
Sonderzeichen 49
sort() 819, 931
sort_heap() 933
Sortieren
Algorithmen-Bibliothek 931
von Listen 819
Sortierverfahren
Bubble-Sort 363
Quick-Sort 729, 739
Selection-Sort- 397, 723
Speicher
dynamisch reservieren
485
freigeben 487
Speicherklasse
extern 225
register 229
static 227
von Funktionen 231
von Variablen 223
Speicherleck 848
Speichermodell 805
Speicherplatz 53
für Datenlemente 273
Speicherreservierung
dynamische 485
Speicherzugriff
konkurrierend 881
Spezifikation
Exception 657
Spezifizierer 225, 586
splice() 497
Sprung 135
Sprungtabelle 729
sqrt() 62, 75, 943, 951
srand() 67
sstream 70
Stack 201, 209, 803, 881
-Unwinding 655
stack 70, 804
Standard
Allokator-Klasse 805
-Ausgabe 81
-Ein-/Ausgabe 153
-Eingabe 81
-Fehlerklassen siehe
Fehlerklasse
-Funktion, Prototyp 63
-Header-Datei 63, 71
-Klassen 73
-Konvertierung 475
-Kopierkonstruktor 517
-Makros 151, 971
-Methoden 519
-Namensbereich 233
-Streams 81
-Zuweisung 519, 613
StandardStreams 81
Standardbibliothek 29, 195
Standardfunktion
bsearch() 973
mathematische 62
qsort() 729, 738, 973
terminate() 653
Standardklasse
Siehe auch Klasse
Container 801
File-Stream 411
string 177
stringstream 316
Standardmethoden 305
Standardwert 293
Stapel 201
start() 957
static 227, 231, 335
static_cast<_> 577
statisch 223
Bindung 591
Datenelement 333
Elementfunktion 335
Status
Datei- 685
-Flag 415
Flag von Dateien 685
-Wort 685
std 31, 71, 233
stdarg.h 70, 725
stddef.h 70
stdexcept 70
stdio.h 70
stdlib.h 70
Steuerung
peripherer Geräte 145
Steuerzeichen 49, 761
ausblenden 155
Bildschirm 979
Strategie
Überlauf- 698
strcat() 391
strcmp() 355
strcpy() 355, 386, 391
Stream 31, 79
-Klassen 81
Standard- 81
streambuf 70
Stream-Iterator 917
stride() 957
String 45, 73
anhängen 179
Ausgabe 91
einfügen 183
Elementzugriff 187
-Ende-Zeichen 355
ersetzen 185
Konstante 47
-Länge 177
leerer 47, 177
löschen 183
manipulieren 183
suchen 185
Teil- 185
vergleichen 181
Verkettung 179
zuweisen 177
string 70
Header-Datei 177
Standardklasse 177
string.h 70
Stringende-Zeichen 47
stringizing token 965
stringstream 316
strlen() 355, 385
Stroustrup
Bjarne 25
strstr() 391
struct 281
Struktogramm 126, 128
Struktur
rekursiv 209
tm 285
von C++-Programmen
33
Subtraktion
von Zeigern 381, 383
1015
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Stichwortverzeichnis
Suche
binäre 697, 812, 933
in Bereichen 921
in Maps 825
in Strings 185
sum() 951
swap() 259, 311
swapping 485
switch
-Anweisung 133
Symbol 149
symbolisch
Konstante 143
Symmetrie
von Argumenten 311
sync() 92
Syntaxfehler 29
Systemzeit 285
T
Tabelle
ASCII-Code 977
Hash- 803, 829
virtuelle Methoden- 591
Vorrang- 976
Tabulatorbreite 49
Tabulatorzeichen 49
tan() 62, 943
tanh() 943
Tasten
Sonder- 154
Teil
-String 185
Teilmatrix 955
Teilobjekt 275, 327
initialisieren 329
konstantes 331
Teilvektor 953
tellg() 681
tellp() 681
TEMP 398
Template 770
Container- 805
terminate() 653
Test
Performance- 739
Text
Ersatz- 143
Textdatei 414
Textmodus 414
Textzeile
einlesen 97
this 309
this_thread 885
Thread 881
-ID 889
initialisieren 883
throw 651
Tilde 297
time() 136, 189, 285
time.h 70
time_t 285
tm 284
Token 33
Past- 966
stringizing 965
tolower() 151
top() 813
Top-Down-Prinzip 195
transform() 925
Transponierte 959
Treiber
Bildschirm 979
Treppe
zeichnen 789
true 39, 111
trunc 414
try 653
Typ Siehe Datentyp 43
arithmetischer 42
einer Funktion 63
eines Ausdrucks 105
enum 337
-Feld 585
Funktion 197
ganzzahliger 43
-Information zur Laufzeit 592
maschinenabhängiger
733
Parameter 197
void 67, 199
von Zeigern 255
Typanpassung
implizite 163
übliche arithmetische
751
type_traits 70
typedef 733
typeinfo 70
typenlos 379
Typname
Definition 733
Typumwandlung
arithmetische 163
ausschließen 477
bei Funktionsaufrufen
571
bei Zuweisungen 167,
573
explizite 169
für Klassen 473
implizite in Basisklassen
571
in Klassenhierarchien
571
Standard- 475
Verfahren 165
von Referenzen 575
von Zeigern 575
U
Überladung
von Funktionen 207
Überlauf
-Strategie 698
Übersetzungeinheit 223
Umgebung
eines Programms 399
Umgebungsvariable 967
Umlenken
von Ein-/Ausgabe 153
Umwandlung
von Datentypen 163
underflow_error 660
UND-Operator 113, 751
union 283
unique( 857
unique_ptr 850
UNIX 153
unlock() 887
unsetf() 82
Unterprogrammsprung 203
Unwinding
Stack- 655
Up-Cast 577
uppercase 84
use_count() 857
User Network Interface 759
using 71
Deklaration 235
-Direktive 31, 235
utility 70
1016
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Stichwortverzeichnis
V
va_end() 727
va_list 725
va_start() 725
valarray 70, 945
value
high- 172
Variable 53
extern 225
global 53
Klassen- 333
lokal 53
lokale 201
PATH- 153
register- 229
Zeiger- 255
vector 70, 804, 805
Vektor 351
Adresse 379
als Argument 385
als Datenelement 361
assoziativer 457
char- 355
Container 805
-Element 351
globaler 353
Länge 351
lokaler 353
mehrdimensionaler 359
-Name 351
numerischer 945
statischer 353
von Zeigern 393, 723
Zuweisung 353
Vereinbarung
von Variablen 53
Vererbung 25
Art 541
-Diagramm 631, 635
Konzept 539
Mehrfach- 629
Verfahren
Routing- 835
Sortier- 363, 723
Vergleich 39, 111
-Funktion 738
lexikografischer 181
von Schlüsseln 821
von Strings 181
von Zeigern 383
Vergleichsoperator 111, 181
Verkettung
von Strings 179
Verschachteln
von Schleifen 125
von Verzweigungen 127
Verschachtelungstiefe
von Schleifen 125
Verschiebung
von Bits 753
Verschlüsselung
von Daten 761
Version
einer Klasse 269
Index- 387
von Funktionen 205
von Klassen 301
von Methoden 551, 587
Zeiger- 387
Verweis
Operator 257
virtual 587
Basisklasse 633
Virtual Method Table 591
virtuell
Methode 585
Visual Studio 980
Community 980
Express 980
VMT 591
void 43, 67, 199
void * 379
volatile 55
Vorrang 105, 442
arithmetischer Operatoren 107
Auswahloperator 131
boolescher Operatoren
113
von Bitoperatoren 751
Vorrangtabelle 107
für Operatoren 976
Vorzeichen 41, 962, 964
-Bit 165, 962
-Erweiterung 165
-Operator 107
W
Währung
europäische 447
wahlfrei
Dateizugriff 409, 679
Wahrheitswert 39
wait() 895
Warnung 29
Warteschlange
mit Prioritäten 805
Warteschlangen 803
wchar.h 70
wchar_t 39
wctype.h 70
weak_ptr 850, 862
Wegefindung 835
Wert
Absolut- 131, 963
boolescher 39
eines Ausdrucks 105
L- 257
R- 257
Wertebereich 964
what() 661
while
Schleife 119
width() 88, 355
Wiederholung 135
Wiederverwendbarkeit 27,
539
von Klassen 273
Wiederverwendung 195
WinNT 153
Wort 93
Status- 685
write() 419
Wurzel
komplexe 937
Z
Zähler
Schleifen- 121
Zahl
Darstellung 962
Fibonacci- 353
komplexe 937
negative 85, 964
PI 143
positive 962
Prim- 363
Zahlensystem 85
Zeichen
Begrenzungs- 97
Behandlung von 151
Steuer- 761, 979
Stringende 47
Zugriff 187
Zwischenraum- 93
1017
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
Stichwortverzeichnis
Zeichencode
Ausgabe 91
Zeichenkette 45, 177
Zeichenkonstante 47
Zeichensatz 39
Zeiger 255
als Parameter 259
als Return-Wert 313, 391
-Arithmetik 381, 383
auf abstrakte Klassen
611
auf const-Objekt 389
auf Funktionen 729
auf Objekte 279
auf Zeiger 723
get-/put- 679
konstanter 255, 309
NULL- 487
Null- 256
Read-Only- 389
this 309
typenloser 379
und Vektoren 379
-Vektor 393, 723
vergleichen 383
-Version von Funktionen 387
Zeigervariable
Definition 255
Zeilennummer 153, 969
Zeit 285
zero
extend 165
Zerstören
von Objekten 297
Ziffer
hexadezimale 85
Zufallszahl 67
Zufallszahlengenerator 67,
136
Zugriff
auf Basisklasse 547
auf Container 813
auf Daten 269
auf private-Elemente
277
Element- 545
fehlerhafter 301
-Methoden 301
wahlfreier Datei- 679
Zugriffsrechte
bei Vererbung 541
Zusammenfassung 107
Zuweisung 442
einfache 109
implizite Typumwandlung 167
Move- 525
Standard- 519
Typumwandlung 573
überladen 519
virtuelle 613
von Objekten 277, 305
von Strings 177
zusammengesetzte 109,
757
Zuweisungsoperator 109
Zweier-Komplement 165,
963
Zweier-Potenz 753
Zweig
else- 127
Zwischenraumzeichen 93
1018
© des Titels »C++ – Lernen und professionell anwenden« (ISBN 9783958450288) 2015 by
mitp Verlags GmbH & Co. KG, Frechen. Nähere Informationen unter: http://www.mitp.de/028
