Der C++ - Programmierer

// C++ LERNEN // PROFESSIONELL ANWENDEN // LÖSUNGEN NUTZEN //
ulrich BREYMANN
DER
PROGRAMMIERER
C++
Inhalt
Vorwort ........................................................................................... 21
Teil I:
Einführung in C++ ................................................................... 25
1
Es geht los! ............................................................................... 27
1.1
Historisches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
1.2
Objektorientierte Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
1.3
Compiler. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
1.4
Das erste Programm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
1.4.1
1.5
1.6
Namenskonventionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Integrierte Entwicklungsumgebungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
1.5.1
Code::Blocks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
1.5.2
Eclipse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
1.5.3
KDevelop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Einfache Datentypen und Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
1.6.1
Ausdruck . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
1.6.2
Ganze Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
1.6.3
Reelle Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
1.6.4
Konstante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
1.6.5
Zeichen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
1.6.6
Logischer Datentyp bool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
1.6.7
Referenzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
1.6.8
Regeln zum Bilden von Ausdrücken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
6
Inhalt
1.6.9
1.7
1.7.1
1.8
1.9
Standard-Typumwandlungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Gültigkeitsbereich und Sichtbarkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
Namespace std . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
Kontrollstrukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
1.8.1
Anweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
1.8.2
Sequenz (Reihung) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
1.8.3
Auswahl (Selektion, Verzweigung) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
1.8.4
Fallunterscheidungen mit switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
1.8.5
Wiederholungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.8.6
Kontrolle mit break und continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
71
Benutzerdefinierte und zusammengesetzte Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
1.9.1
Aufzählungstypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
1.9.2
Arrays: Der C++-Standardtyp vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
1.9.3
Zeichenketten: Der C++-Standardtyp string . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
1.9.4
Strukturierte Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
2
Einfache Ein- und Ausgabe ............................................................ 93
2.1
Standardein- und -ausgabe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
2.2
Ein- und Ausgabe mit Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
3
Programmstrukturierung .............................................................. 101
3.1
Funktionen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
3.2
3.3
3.1.1
Aufbau und Prototypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
3.1.2
Gültigkeitsbereiche und Sichtbarkeit in Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . 104
Schnittstellen zum Datentransfer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
3.2.1
Übergabe per Wert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
3.2.2
Übergabe per Referenz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
3.2.3
Gefahren bei der Rückgabe von Referenzen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
3.2.4
Vorgegebene Parameterwerte und variable Parameterzahl . . . . . . . . . . . . . . . . . . . 113
3.2.5
Überladen von Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
3.2.6
Funktion main() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
3.2.7
Beispiel Taschenrechnersimulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
3.2.8
Spezifikation von Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
Modulare Programmgestaltung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
3.3.1
Steuerung der Übersetzung nur mit #include . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
3.3.2
Einbinden vorübersetzter Programmteile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
3.3.3
Dateiübergreifende Gültigkeit und Sichtbarkeit. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
3.3.4
Übersetzungseinheit, Deklaration, Definition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
Inhalt
3.3.5
3.4
Compilerdirektiven und Makros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
Funktions-Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
3.4.1
Spezialisierung von Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
3.4.2
Einbinden von Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
3.5
inline-Funktionen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
3.6
Namensräume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
3.7
C++-Header . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
3.7.1
Einbinden von C-Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
4
Objektorientierung 1 .................................................................... 147
4.1
Abstrakte Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
4.2
Klassen und Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
4.2.1
4.3
4.4
inline-Elementfunktionen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
Initialisierung und Konstruktoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
4.3.1
Standardkonstruktor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
4.3.2
Allgemeine Konstruktoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
4.3.3
Kopierkonstruktor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
4.3.4
Typumwandlungskonstruktor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
Beispiel: Rationale Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
4.4.1
Aufgabenstellung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
4.4.2
Entwurf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
4.4.3
Implementation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
4.5
const-Objekte und Methoden. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
4.6
Destruktoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
4.7
Wie kommt man zu Klassen und Objekten? Ein Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
4.7.1
Einige Analyse-Überlegungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
4.7.2
Formulierung des Szenarios in C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
4.8
Gegenseitige Abhängigkeit von Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
4.9
Delegierender Konstruktor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
5
Intermezzo: Zeiger ...................................................................... 183
5.1
Zeiger und Adressen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
5.2
C-Arrays. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
5.3
5.2.1
C-Arrays und sizeof . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
5.2.2
Indexoperator bei C-Arrays. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
5.2.3
Initialisierung von C-Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
5.2.4
Zeigerarithmetik. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
C-Zeichenketten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
7
8
Inhalt
5.4
Dynamische Datenobjekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
5.4.1
5.5
5.6
Freigeben dynamischer Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
Zeiger und Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
5.5.1
Parameterübergabe mit Zeigern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
5.5.2
Parameter des main-Programms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
5.5.3
Gefahren bei der Rückgabe von Zeigern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
Mehrdimensionale C-Arrays. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
5.6.1
Statische mehrdimensionale C-Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
5.6.2
Dynamisch erzeugte mehrdimensionale Arrays. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
5.6.3
Klasse für dynamisches zweidimensionales Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
5.7
Binäre Ein-/Ausgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
5.8
Zeiger auf Funktionen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
5.9
this-Zeiger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
5.10 Komplexe Deklarationen lesen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224
5.11 Standard-Typumwandlungen für Zeiger. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226
5.12 Zeiger auf Elementfunktionen und -daten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
5.12.1
Zeiger auf Elementfunktionen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
5.12.2
Zeiger auf Elementdaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228
6
Objektorientierung 2 ...................................................................229
6.1
Eine String-Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
6.2
6.1.1
Optimierung der Klasse MeinString . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234
6.1.2
friend-Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
Klassenspezifische Daten und Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238
6.2.1
6.3
Klassenspezifische Konstante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241
Klassen-Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242
6.3.1
Ein Stack-Template . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242
6.3.2
Stack mit statisch festgelegter Größe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
6.4
Template-Metaprogrammierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
6.5
Variadic Templates: Templates mit variabler Parameterzahl . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
7
Vererbung .................................................................................253
7.1
Vererbung und Initialisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
7.2
Zugriffsschutz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260
7.3
Typbeziehung zwischen Ober- und Unterklasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
7.4
Code-Wiederverwendung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263
7.5
Überschreiben von Funktionen in abgeleiteten Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264
7.6
Polymorphismus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266
Inhalt
7.6.1
Virtuelle Funktionen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266
7.6.2
Abstrakte Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271
7.6.3
Virtueller Destruktor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276
7.7
Probleme der Modellierung mit Vererbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278
7.8
Mehrfachvererbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281
7.9
7.8.1
Namenskonflikte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284
7.8.2
Virtuelle Basisklassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285
Standard-Typumwandlungsoperatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288
7.10 Typinformationen zur Laufzeit. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291
7.11 Using-Deklaration für Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292
7.12 Private- und Protected-Vererbung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293
8
8.1
Fehlerbehandlung ........................................................................297
Ausnahmebehandlung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299
8.1.1
Exception-Spezifikation in Deklarationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302
8.1.2
Exception-Hierarchie in C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303
8.1.3
Besondere Fehlerbehandlungsfunktionen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305
8.1.4
Erkennen logischer Fehler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306
8.2
Speicherbeschaffung mit new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308
8.3
Exception-Sicherheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311
9
Überladen von Operatoren ............................................................ 313
9.1
Rationale Zahlen — noch einmal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315
9.2
9.1.1
Arithmetische Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315
9.1.2
Ausgabeoperator << . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318
Eine Klasse für Vektoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319
9.2.1
Index-Operator [ ] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322
9.2.2
Zuweisungsoperator = . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324
9.2.3
Zuweisungsoperator und Vererbung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326
9.2.4
Mathematische Vektoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
9.2.5
Multiplikationsoperator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332
9.3
Inkrement-Operator ++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333
9.4
Typumwandlungsoperator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337
9.5
Smart Pointer: Operatoren -> und * . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
9.5.1
Smart Pointer und die C++-Standardbibliothek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344
9.6
Objekt als Funktion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344
9.7
new und delete überladen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346
9.7.1
Speichermanagement mit malloc und free . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349
9
10
Inhalt
9.8
10
9.7.2
Unterscheidung zwischen Heap- und Stack-Objekten . . . . . . . . . . . . . . . . . . . . . . . . 351
9.7.3
Fehlende delete-Anweisung entdecken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352
9.7.4
Eigene Speicherverwaltung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353
9.7.5
Empfehlungen im Umgang mit new und delete . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357
Mehrdimensionale Matrizen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358
9.8.1
Zweidimensionale Matrix als Vektor von Vektoren . . . . . . . . . . . . . . . . . . . . . . . . . . . 359
9.8.2
Dreidimensionale Matrix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
Dateien und Ströme .....................................................................365
10.1 Ausgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367
10.1.1
Formatierung der Ausgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367
10.2 Eingabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370
10.3 Manipulatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373
10.3.1
Eigene Manipulatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376
10.4 Fehlerbehandlung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377
10.4.1
Exception ios::failure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379
10.5 Typumwandlung von Dateiobjekten nach bool. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379
10.6 Arbeit mit Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 380
10.6.1
Positionierung in Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381
10.6.2
Lesen und Schreiben in derselben Datei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382
10.7 Umleitung auf Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383
10.8 Ergänzungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385
11
Einführung in die Standard Template Library (STL) .............................387
11.1 Das Konzept: Container, Iteratoren, Algorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389
11.2 Iteratoren im Detail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393
11.3 Beispiel verkettete Liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 394
12
Reguläre Ausdrücke ....................................................................399
12.1 Elemente regulärer Ausdrücke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400
12.1.1
Greedy oder lazy? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 402
12.2 Interaktive Auswertung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403
12.3 Auszug des regex-APIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 406
12.4 Anwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408
13
Threads ....................................................................................409
13.1 Die Klasse thread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413
13.2 Synchronisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416
Inhalt
13.2.1
Thread-Group . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 418
13.3 Thread-Steuerung: pausieren, fortsetzen, beenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 419
13.4 Interrupt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424
13.5 Warten auf Ereignisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426
13.6 Reader/Writer-Problem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 431
13.6.1
Wenn Threads verhungern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435
13.6.2
Reader/Writer-Varianten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437
13.7 Thread-Sicherheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 438
Teil II:
14
Bausteine komplexer Anwendungen ............................................439
Grafische Benutzungsschnittstellen ................................................ 441
14.1 Ereignisgesteuerte Programmierung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 442
14.2 GUI-Programmierung mit Qt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443
14.2.1
Meta-Objektsystem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443
14.2.2
Der Programmablauf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444
14.2.3
Speicher sparen und lokal Daten sichern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445
14.3 Signale, Slots und Widgets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447
14.4 Dialog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455
14.5 Qt oder Boost?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 458
15
14.5.1
Threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 459
14.5.2
Verzeichnisbaum durchwandern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 460
Internet-Anbindung .....................................................................463
15.1 Protokolle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464
15.2 Adressen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464
15.3 Socket . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 468
15.3.1
Bidirektionale Kommunikation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 471
15.3.2
UDP-Sockets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 473
15.3.3
Atomuhr mit UDP abfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 474
15.4 HTTP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 477
15.4.1
Verbindung mit GET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 478
15.4.2
Verbindung mit POST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 483
15.5 Mini-Webserver . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 483
16
Datenbankanbindung ...................................................................493
16.1 C++-Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 494
16.2 Anwendungsbeispiel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 498
11
12
Inhalt
Teil III:
17
Praktische Methoden und Werkzeuge der Softwareentwicklung ........505
Abläufe automatisieren mit make ...................................................507
17.1 Quellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 508
17.2 Wirkungsweise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 509
17.3 Variablen und Muster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 511
17.4 Universelles Makefile für einfache Projekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 512
18
Unit-Test ................................................................................... 515
18.1 Werkzeuge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 516
18.2 Test Driven Development . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 517
18.3 Boost Unit Test Framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 518
19
18.3.1
Testaufbau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 519
18.3.2
Beispiel: Testgetriebene Entwicklung einer Operatorfunktion . . . . . . . . . . . . . . . 520
18.3.3
Fixture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 524
18.3.4
Testprotokoll und Log-Level . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 525
18.3.5
Prüf-Makros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 526
18.3.6
Kommandozeilen-Optionen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 530
Werkzeuge zur Verwaltung von Projekten ......................................... 531
19.1 Dokumentation und Strukturanalyse mit doxygen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 531
19.1.1
Strukturanalyse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 535
19.2 Versionskontrolle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 536
19.2.1
Einrichtung des Servers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 538
19.2.2
Exemplarische Benutzung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 541
19.3 Projektverwaltung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543
19.3.1
Projektmanagement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543
19.3.2
Wiki für Software-Entwicklungsprojekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543
Teil IV:
20
Das C++-Rezeptbuch: Tipps und Lösungen für typische Aufgaben.....545
Sichere Programmentwicklung .......................................................547
20.1 Regeln zum Design von Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 547
20.2 Defensive Programmierung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 550
20.2.1
double- und float-Werte richtig vergleichen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 551
20.2.2
const verwenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 551
20.2.3
Anweisungen nach for/if/while einklammern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 552
20.2.4
int und unsigned nicht mischen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 552
Inhalt
20.2.5
Postfix++ mit Präfix++ implementieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 552
20.2.6
Ein Destruktor darf keine Exception werfen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553
20.2.7
Typumwandlungsoperatoren vermeiden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 554
20.2.8
explicit-Konstruktoren bevorzugen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 554
20.2.9
Leere Standardkonstruktoren vermeiden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 554
20.2.10 Kopieren und Zuweisung verbieten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 554
20.2.11 Vererbung verbieten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 556
20.2.12 Defensiv Objekte löschen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 557
20.3 Exception-sichere Beschaffung von Ressourcen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 557
20.3.1
Sichere Verwendung von shared_ptr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 557
20.3.2
shared_ptr für Arrays korrekt verwenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 558
20.3.3
Exception-sichere Funktion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 558
20.3.4
Exception-sicherer Konstruktor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 559
20.3.5
Exception-sichere Zuweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 560
20.4 Aussagefähige Fehlermeldung ohne neuen String erzeugen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 562
20.5 Empfehlungen zur Thread-Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 563
21
20.5.1
Warten auf die Freigabe von Ressourcen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 563
20.5.2
Deadlock-Vermeidung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 564
20.5.3
notify_all oder notify_one?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 564
20.5.4
Performance mit Threads verbessern?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 565
Von der UML nach C++ .................................................................567
21.1 Vererbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 568
21.2 Interface anbieten und nutzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 568
21.3 Assoziation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 570
22
21.3.1
Aggregation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 573
21.3.2
Komposition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 573
Performance, Wert- und Referenzsemantik .......................................575
22.1 Performanceproblem Wertsemantik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 577
22.2 Optimierung durch Referenzsemantik für R-Werte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 578
22.3 Ein effizienter binärer Plusoperator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 580
23
Effektive Programmerzeugung .......................................................585
23.1 Automatische Ermittlung von Abhängigkeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 586
23.1.1
Getrennte Verzeichnisse: src, obj, bin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 587
23.2 Makefile für Verzeichnisbäume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 589
23.2.1
Rekursive Make-Aufrufe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 590
13
14
Inhalt
23.2.2
Ein Makefile für alles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 592
23.3 Automatische Erzeugung von Makefiles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593
23.3.1
Makefile für rekursive Aufrufe erzeugen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594
23.4 Erzeugen von Bibliotheken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 595
23.4.1
Statische Bibliotheksmodule . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 596
23.4.2
Dynamische Bibliotheksmodule . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 597
23.5 GNU Autotools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 600
23.6 CMake . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 603
23.7 Code Bloat bei der Instanziierung von Templates vermeiden . . . . . . . . . . . . . . . . . . . . . . . . . . . 603
24
23.7.1
extern-Template . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 605
23.7.2
Aufspaltung in Schnittstelle und Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 606
23.7.3
export-Template . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 607
Algorithmen für verschiedene Aufgaben ...........................................609
24.1 Algorithmen mit Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 610
24.1.1
String splitten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 610
24.1.2
String in Zahl umwandeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 611
24.1.3
Zahl in String umwandeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 612
24.1.4
Strings sprachlich richtig sortieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 613
24.1.5
Umwandlung in Klein- bzw. Großschreibung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 614
24.1.6
Strings sprachlich richtig vergleichen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 616
24.1.7
Von der Groß-/Kleinschreibung unabhängiger Zeichenvergleich . . . . . . . . . . . 617
24.1.8
Von der Groß-/Kleinschreibung unabhängige Suche . . . . . . . . . . . . . . . . . . . . . . . . . 618
24.2 Textverarbeitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 619
24.2.1
Datei durchsuchen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 619
24.2.2
Ersetzungen in einer Datei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 621
24.2.3
Code-Formatierer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 623
24.2.4
Lines of Code (LOC) ermitteln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 624
24.2.5
Zeilen, Wörter und Zeichen einer Datei zählen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 626
24.2.6
CSV-Datei lesen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 626
24.2.7
Kreuzreferenzliste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 627
24.3 Operationen auf Folgen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 630
24.3.1
Container anzeigen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 630
24.3.2
Folge mit gleichen Werten initialisieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 631
24.3.3
Folge mit Werten eines Generators initialisieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 631
24.3.4
Folge mit fortlaufenden Werten initialisieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 632
24.3.5
Summe und Produkt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 632
Inhalt
24.3.6
Mittelwert und Standardabweichung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 633
24.3.7
Skalarprodukt. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 634
24.3.8
Folge der Teilsummen oder -produkte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 635
24.3.9
Folge der Differenzen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 636
24.3.10 Minimum und Maximum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 637
24.3.11 Elemente rotieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 639
24.3.12 Elemente verwürfeln. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 640
24.3.13 Dubletten entfernen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 641
24.3.14 Reihenfolge umdrehen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 643
24.3.15 Anzahl der Elemente, die einer Bedingung genügen . . . . . . . . . . . . . . . . . . . . . . . . . . 644
24.3.16 Gilt X für alle, keins oder wenigstens ein Element einer Folge? . . . . . . . . . . . . 645
24.3.17 Permutationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 646
24.3.18 Lexikografischer Vergleich. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 647
24.4 Sortieren und Verwandtes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 648
24.4.1
Partitionieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 648
24.4.2
Sortieren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 650
24.4.3
Stabiles Sortieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 650
24.4.4
Partielles Sortieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 651
24.4.5
Das n.-größte oder n.-kleinste Element finden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 652
24.4.6
Verschmelzen (merge) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 653
24.5 Suchen und Finden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 657
24.5.1
Element finden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 657
24.5.2
Element einer Menge in der Folge finden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 658
24.5.3
Teilfolge finden. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 659
24.5.4
Bestimmte benachbarte Elemente finden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 661
24.5.5
Bestimmte aufeinanderfolgende Werte finden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 662
24.5.6
Binäre Suche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 664
24.6 Mengenoperationen auf sortierten Strukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 667
24.6.1
Teilmengenrelation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 667
24.6.2
Vereinigung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 668
24.6.3
Schnittmenge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 669
24.6.4
Differenz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 669
24.6.5
Symmetrische Differenz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 670
24.7 Heap-Algorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 671
24.7.1
pop_heap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 672
24.7.2
push_heap. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 673
24.7.3
make_heap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 674
15
16
Inhalt
24.7.4
sort_heap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 674
24.7.5
is_heap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 675
24.8 Vergleich von Containern auch ungleichen Typs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 675
24.8.1
Unterschiedliche Elemente finden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 675
24.8.2
Prüfung auf gleiche Inhalte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 677
24.9 Rechnen mit komplexen Zahlen: Der C++-Standardtyp complex . . . . . . . . . . . . . . . . . . . . . . 678
24.10 Schnelle zweidimensionale Matrix mit zusammenhängendem Speicher . . . . . . . . . . . . . . 680
24.10.1 Optimierung mathematischer Array-Operationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 685
24.11 Vermischtes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 689
24.11.1 Erkennung eines Datums. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 689
24.11.2 Erkennung einer IP-Adresse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 691
24.11.3 Erzeugen von Zufallszahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 692
24.11.4 for_each — Auf jedem Element eine Funktion ausführen . . . . . . . . . . . . . . . . . . . . 693
24.11.5 Verschiedene Möglichkeiten, Container-Bereiche zu kopieren. . . . . . . . . . . . . . . 693
24.11.6 Vertauschen von Elementen, Bereichen und Containern . . . . . . . . . . . . . . . . . . . . . 696
24.11.7 Elemente transformieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 696
24.11.8 Ersetzen und Varianten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 698
24.11.9 Elemente herausfiltern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 700
24.11.10 Minimum und Maximum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 701
24.11.11 Grenzwerte von Zahltypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 701
25
Ein- und Ausgabe ........................................................................703
25.1 Datei- und Verzeichnisoperationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 703
25.1.1
Datei oder Verzeichnis löschen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 704
25.1.2
Datei oder Verzeichnis umbenennen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 705
25.1.3
Verzeichnis anlegen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 706
25.1.4
Verzeichnis anzeigen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 707
25.1.5
Verzeichnisbaum anzeigen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 708
25.2 Tabelle formatiert ausgeben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 710
25.3 Formatierte Daten lesen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 711
25.3.1
Eingabe benutzerdefinierter Typen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 711
25.4 Array als Block lesen oder schreiben. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 713
Teil V:
26
Die C++-Standardbibliothek ...................................................... 715
Aufbau und Übersicht .................................................................. 717
26.1 Auslassungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 719
Inhalt
26.2 Beispiele des Buchs und die C++-Standardbibliothek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 721
27
Hilfsfunktionen und -klassen ......................................................... 723
27.1 Relationale Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 723
27.2 Unterstützung der Referenzsemantik für R-Werte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 724
27.3 Paare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 727
27.4 Tupel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 729
27.5 Funktionsobjekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 729
27.5.1
Arithmetische, vergleichende und logische Operationen . . . . . . . . . . . . . . . . . . . . . 730
27.5.2
Funktionsobjekte zum Negieren logischer Prädikate . . . . . . . . . . . . . . . . . . . . . . . . . . 731
27.5.3
Binden von Argumentwerten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 732
27.5.4
Zeiger auf Funktionen in Objekte umwandeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 733
27.6 Templates für rationale Zahlen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 734
27.7 Zeit und Dauer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 735
27.8 Hüllklasse für Referenzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 735
28
Container .................................................................................. 737
28.1 Gemeinsame Eigenschaften. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 739
28.1.1
Initialisierungslisten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 741
28.1.2
Konstruktion an Ort und Stelle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 742
28.1.3
Reversible Container . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 742
28.2 Sequenzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 743
28.2.1
vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 744
28.2.2
vector<bool> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 745
28.2.3
list . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 746
28.2.4
deque . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 748
28.2.5
stack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 749
28.2.6
queue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 751
28.2.7
priority_queue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 752
28.2.8
array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 754
28.3 Sortierte assoziative Container . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 756
28.3.1
map . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 756
28.3.2
multimap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 760
28.3.3
set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 761
28.3.4
multiset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 764
28.4 Hash-Container. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 765
28.4.1
unordered_map . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 767
28.4.2
unordered_multimap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 771
17
18
Inhalt
28.4.3
unordered_set. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 772
28.4.4
unordered_multiset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 774
28.5 bitset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 775
29
Iteratoren ................................................................................. 779
29.1 Iterator-Kategorien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 780
29.1.1
Anwendung von Traits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 782
29.2 distance() und advance() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 784
29.3 Reverse-Iteratoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 785
29.4 Insert-Iteratoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 786
29.5 Stream-Iteratoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 787
30
Algorithmen ..............................................................................789
30.1 Algorithmen mit Prädikat. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 790
30.1.1
Algorithmen mit binärem Prädikat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 790
30.2 Übersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 791
31
Nationale Besonderheiten .............................................................795
31.1 Sprachumgebungen festlegen und ändern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 796
31.1.1
Die locale-Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 797
31.2 Zeichensätze und -codierung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 798
31.3 Zeichenklassifizierung und -umwandlung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 802
31.4 Kategorien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 803
31.4.1
collate. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 803
31.4.2
ctype . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 804
31.4.3
numeric . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 805
31.4.4
monetary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 807
31.4.5
time . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 810
31.4.6
messages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 812
31.5 Konstruktion eigener Facetten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 813
32
String ...................................................................................... 815
33
Speichermanagement ..................................................................823
33.1 Smart Pointer unique_ptr, shared_ptr, weak_ptr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 823
33.2 new mit vorgegebenem Speicherort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 828
33.3 Hilfsfunktionen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 829
Inhalt
34
Optimierte numerische Arrays (valarray) ......................................... 831
34.1 Konstruktoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 832
34.2 Elementfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 832
34.3 Binäre Valarray-Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 835
34.4 Mathematische Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 837
34.5 slice und slice_array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 838
34.6 gslice und gslice_array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 840
34.7 mask_array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 843
34.8 indirect_array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 844
35
C-Header ..................................................................................847
35.1 <cassert> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 848
35.2 <cctype> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 848
35.3 <cerrno> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 849
35.4 <cmath>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 849
35.5 <cstdarg> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 850
35.6 <cstddef>. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 851
35.7 <cstdio> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 851
35.8 <cstdlib> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 851
35.9 <cstring> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 853
35.10 <ctime> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 855
A
Anhang .....................................................................................857
A.1
Programmierhinweise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 857
A.2
C++-Schlüsselwörter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 860
A.3
ASCII-Tabelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 861
A.4
Rangfolge der Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 862
A.5
Compilerbefehle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 863
A.6
Änderungen des C++-Standards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 864
A.6.1
Änderungen/Erweiterungen der C++-Sprache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 864
A.6.2
Änderungen/Erweiterungen der C++-Standardbibliothek . . . . . . . . . . . . . . . . . . . . 871
A.7
Lösungen zu den Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 872
A.8
Installation der DVD-Software für Windows. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 917
A.9
A.8.1
Installation des Compilers und einiger Bibliotheken . . . . . . . . . . . . . . . . . . . . . . . . . . 917
A.8.2
Bei Verzicht auf die automatische Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 918
A.8.3
Codeblocks einrichten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 919
A.8.4
Integration von Qt in ein Code::Blocks-Projekt. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 921
Installation der DVD-Software für Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 922
19
20
Inhalt
A.9.1
Installation des Compilers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 922
A.9.2
Installation von Boost . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 923
A.9.3
Installation von Code::Blocks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 923
A.9.4
Code::Blocks einrichten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 924
A.9.5
Beispieldateien entpacken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 924
A.9.6
Installation von Qt4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 925
A.9.7
Integration von Qt in ein Code::Blocks-Projekt. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 926
Literaturverzeichnis ...........................................................................927
Glossar ............................................................................................ 931
Register........................................................................................... 941
1
Es geht los!
Dieses Kapitel behandelt die folgenden Themen:
Entstehung und Entwicklung der Programmiersprache C++
Objektorientierte Programmierung – Erste Grundlagen
Wie schreibe ich ein Programm und bringe es zum Laufen?
Einfache Datentypen und Operationen
Ablauf innerhalb eines Programms steuern
Erste Definition eigener Datentypen
Standarddatentypen vector und string
1.1 Historisches
C++ wurde etwa ab 1980 von Bjarne Stroustrup als Sprache, die Objektorientierung
stark unterstützt, entwickelt und 1998 von der ISO (International Standards Organisation)
und der IEC (International Electrotechnical Commission) standardisiert. Diesem Standard
haben sich nationale Standardisierungsgremien wie ANSI (USA) und DIN (Deutschland)
angeschlossen. Mittlerweile ist der C++-Standard, zu dem es 2003 einige Korrekturen gab,
in die Jahre gekommen. Die Anforderungen an C++ sind gewachsen, auch zeigte sich,
dass manches im Standard fehlte und anderes überflüssig oder fehlerhaft war. Das C++Standardkomitee hat kontinuierlich an der Entwicklung des nächsten C++-Standards
gearbeitet. Der Arbeitsname war C++0x, weil es die feste Absicht des Standardkomitees
war, den neuen C++-Standard spätestens 2009 zu verabschieden. Seit Oktober 2006 war
klar, dass es auch nicht früher werden wird; d.h. C++0x wurde zu C++09 [Str07].
28
1 Es geht los!
Abgesehen von einigen wenigen Spracherweiterungen und -änderungen wurde im April
2006 beschlossen, den TR1 (Technical Report 1 [TR1]) mit der Ausnahme spezieller mathematischer Funktionen in den Standard aufzunehmen. Der TR1 besteht aus teilweise erheblichen Erweiterungen der C++-Standardbibliothek. Der TR1 wurde von Boost [boost]
entwickelt, einer Community, die von Mitgliedern der »C++ Standards Committee Library
Working Group« gegründet wurde und an der sich heute Tausende von Entwicklern beteiligen. Bereits vor der Integration in den C++-Standard haben die Boost-Bibliotheken
vielfachen Einsatz gefunden. Weitere Erweiterungen sind unter der Bezeichnung TR2 in
Arbeit. Das C++-Standardkomitee trifft sich mindestens zweimal im Jahr und arbeitet
weiter an dem C++-Standard. Die jeweiligen Änderungen werden veröffentlicht. Um nur
ein Beispiel zu nennen (ohne hier in die Tiefe zu gehen): Im Januar 2008 wurde die
Multi-threading Library in die C++-Standardbibliothek aufgenommen.
1.2 Objektorientierte Programmierung
Nach üblicher Auffassung heißt Programmieren, einem Rechner mitzuteilen, was er tun
soll und wie es zu tun ist. Ein Programm ist ein in einer Programmiersprache formulierter Algorithmus oder, anders ausgedrückt, eine Folge von Anweisungen, die der Reihe
nach auszuführen sind, ähnlich einem Kochrezept, geschrieben in einer besonderen Sprache, die der Rechner »versteht«. Der Schwerpunkt dieser Betrachtungsweise liegt auf den
einzelnen Schritten oder Anweisungen an den Rechner, die zur Lösung einer Aufgabe
abzuarbeiten sind.
Was fehlt hier beziehungsweise wird bei dieser Sicht eher stiefmütterlich behandelt? Der
Rechner muss »wissen«, womit er etwas tun soll. Zum Beispiel soll er
eine bestimmte Summe Geld von einem Konto auf ein anderes transferieren;
eine Ampelanlage steuern;
ein Rechteck auf dem Bildschirm zeichnen.
Häufig, wie in den ersten beiden Fällen, werden Objekte der realen Welt (Konten, Ampelanlage ...) simuliert, das heißt im Rechner abgebildet. Die abgebildeten Objekte haben
eine Identität. Das Was und das Womit gehören stets zusammen. Beide sind also Eigenschaften eines Objekts und sollten besser nicht getrennt werden. Ein Konto kann
schließlich nicht auf Gelb geschaltet werden, und eine Überweisung an eine Ampel ist
nicht vorstellbar.
Ein objektorientiertes Programm kann man sich als Abbildung von Objekten der realen Welt in Software vorstellen. Die Abbildungen werden selbst wieder Objekte genannt.
Klassen sind Beschreibungen von Objekten. Die objektorientierte Programmierung berücksichtigt besonders die Kapselung von Daten und den darauf ausführbaren Funktionen sowie die Wiederverwendbarkeit von Software und die Übertragung von Eigenschaften von Klassen auf andere Klassen, Vererbung genannt. Auf die einzelnen Begriffe wird
noch eingegangen.
1.2 Objektorientierte Programmierung
Das Motiv hinter der objektorientierten Programmierung ist die rationelle und vor allem ingenieurmäßige Softwareentwicklung. Unter »Softwarekrise« wird das Phänomen
verstanden, dass viele Softwareprojekte nicht im geplanten Zeitraum fertig werden, dass
das finanzielle Budget überschritten wird oder die Projekte ganz abgebrochen werden.
Die objektorientierte Programmierung wird als ein Mittel angesehen, das zur Lösung der
»Softwarekrise« beitragen kann.
Wiederverwendung heißt, Zeit und Geld zu sparen, indem bekannte Klassen wiederverwendet werden. Das Leitprinzip ist hier, das Rad nicht mehrfach neu zu erfinden! Unter
anderem durch den Vererbungsmechanismus kann man Eigenschaften von bekannten
Objekten ausnutzen. Zum Beispiel sei Konto eine bekannte Objektbeschreibung mit den
»Eigenschaften« Inhaber, Kontonummer, Betrag, Dispo-Zinssatz und so weiter. In einem
Programm für eine Bank kann nun eine Klasse Waehrungskonto entworfen werden, für die
alle Eigenschaften von Konto übernommen (= geerbt) werden könnten. Zusätzlich wäre
nur noch die Eigenschaft »Währung« hinzuzufügen.
Wie Computer können auch Objekte Anweisungen ausführen. Wir müssen ihnen nur
»erzählen«, was sie tun sollen, indem wir ihnen eine Auf forderung oder Anweisung senden, die in einem Programm formuliert wird. Anstelle der Begriffe »Aufforderung« oder
»Anweisung« wird in der Literatur manchmal Botschaft (englisch message) verwendet,
was jedoch den Aufforderungscharakter nicht zur Geltung bringt. Eine gängige Notation
(= Schreibweise) für solche Aufforderungen ist Objektname.Anweisung( gegebenenfalls
Daten). Beispiele:
dieAmpel.blinken(gelb);
dieAmpel.ausschalten();
/ / keine Daten notwendig!
dieAmpel.einschalten(gruen);
dasRechteck.zeichnen(position, hoehe, breite);
dasRechteck.verschieben(5.0);
/ / Daten in cm
Die Beispiele geben schon einen Hinweis, dass die Objektorientierung uns ein Hilfsmittel
zur Modellierung der realen Welt in die Hand gibt.
Klassen
Es muss unterschieden werden zwischen der Beschreibung von Objekten und den Objekten selbst. Die Beschreibung besteht aus Attributen und Operationen. Attribute bestehen
aus einem Namen und Angaben zum Datenformat der Attributwerte. Eine Kontobeschreibung könnte so aussehen:
Attribute:
Inhaber: Folge von Buchstaben
Kontonummer: Zahl
Betrag: Zahl
Dispo-Zinssatz in %: Zahl
Operationen:
überweisen (Ziel-Kontonummer, Betrag)
abheben(Betrag)
einzahlen(Betrag)
29
30
1 Es geht los!
Eine Aufforderung ist nichts anderes als der Aufruf einer Operation, die auch Methode
genannt wird. Ein tatsächliches Konto k1 enthält konkrete Daten, also Attributwerte,
deren Format mit dem der Beschreibung übereinstimmen muss. Die Tabelle zeigt k1 und
ein weiteres Konto k2.
Tabelle 1.1: Attribute und Werte zweier Konten
Attribut
Inhaber
Kontonummer
Betrag
Dispo-Zinssatz
Wert für Konto k1
Wert für Konto k2
Roberts, Julia
12573001
-200,30 e
13,75 %
Depp, Johnny
54688490
1222,88 e
13,75 %
Julia will Johnny 1000 e überweisen. Dem Objekt k1 wird also der Auftrag mit den
benötigten Daten mitgeteilt:
k1.überweisen(54688490, 1000.00).
Johnny will 22 e abheben. Die Aufforderung wird an k2 gesendet:
k2.abheben(22).
Es scheint natürlich etwas merkwürdig, wenn einem Konto ein Auftrag gegeben wird. In
der objektorientierten Programmierung werden Objekte als Handelnde aufgefasst, die auf
Anforderung selbstständig einen Auftrag ausführen, entfernt vergleichbar einem Sachbearbeiter in einer Firma, der seine eigenen Daten verwaltet und mit anderen Sachbearbeitern kommuniziert, um eine Aufgabe zu lösen.
Die Beschreibung eines tatsächlichen Objekts gibt seine innere Datenstruktur und die
möglichen Operationen oder Methoden an, die auf die inneren Daten anwendbar sind.
Zu einer Beschreibung kann es kein, ein oder beliebig viele Objekte geben.
Die Beschreibung eines Objekts in der objektorientierten Programmierung heißt Klasse.
Die tatsächlichen Objekte heißen auch Instanzen einer Klasse.
Auf die inneren Daten eines Objekts nur mithilfe der vordefinierten Methoden zuzugreifen, dient der Sicherheit der Daten und ist ein allgemein anerkanntes Prinzip. Das Prinzip
wird Datenabstraktion oder Geheimnisprinzip genannt (Details siehe Abschnitt 4.1). Der
Softwareentwickler, der die Methoden konstruiert hat, weiß ja, wie die Daten konsistent (das heißt widerspruchsfrei) bleiben und welche Aktivitäten mit Datenänderungen
verbunden sein müssen. Zum Beispiel muss eine Erhöhung des Kontostands mit einer
Gutschrift oder einer Einzahlung verbunden sein. Außerdem wird jeder Buchungsvorgang protokolliert. Es darf nicht möglich sein, dass jemand anders die Methoden umgeht
und direkt und ohne Protokoll seinen eigenen Kontostand erhöht. Wenn Sie die Unterlagen eines Kollegen haben möchten, greifen Sie auch nicht einfach in seinen Schreibtisch,
sondern Sie bitten ihn darum (= Sie senden ihm eine Aufforderung), dass er sie Ihnen
gibt.
Die hier verwendete Definition einer Klasse als Beschreibung der Eigenschaften einer
Menge von Objekten wird im Folgenden beibehalten. Gelegentlich findet man in der
Literatur andere Definitionen, auf die hier nicht weiter eingegangen wird. Weitere Informationen zur Objektorientierung sind in Kapitel 4 und in der Literatur zu finden, zum
Beispiel in [Bal05].
1.3 Compiler
1.3 Compiler
Compiler sind die Programme, die Ihren Programmtext in eine für den Computer verarbeitbare Form übersetzen. Von Menschen geschriebener und für Menschen lesbarer
Programmtext kann nicht ohne Weiteres vom Computer »verstanden« werden, wohl aber
das vom Compiler erzeugte Ergebnis der Übersetzung. Das Erlernen einer Programmiersprache ohne eigenes praktisches Ausprobieren ist kaum sinnvoll. Deshalb sollten Sie die
Dienste des Compilers möglichst bald anhand der Beispiele nutzen – wie, zeigt Ihnen der
nächste Abschnitt.
Falls Sie nicht schon einen C++-Compiler oder ein C++-Entwicklungssystem haben, um
die Beispiele korrekt zu übersetzen, bietet sich die Benutzung der in Abschnitt 1.5 beschriebenen Entwicklungsumgebungen an. Der unter Linux meistens verwendete Compiler, den es auch für Windows gibt, ist der GNU1 C++-Compiler [GCC]. Die wichtigsten
Befehle für diesen Compiler, der in einer angepassten Form intern auch von der erwähnten Entwicklungsumgebung benutzt wird, finden Sie in Anhang A.5, Seite 863.
Entwicklungsumgebung und Compiler sind kostenlos erhältlich.
1.4 Das erste Programm
Sie lernen hier die Entwicklung eines ganz einfachen Programms kennen. Der erste
Schritt besteht in der Formulierung der Aufgabe. Sie lautet: »Lies zwei Zahlen a und
b von der Tastatur ein. Berechne die Summe beider Zahlen und zeige das Ergebnis auf
dem Bildschirm an.« Die Aufgabe ist so einfach, wie sie sich anhört! Im zweiten Schritt
wird die Aufgabe in die Teilaufgaben »Eingabe«, »Berechnung« und »Ausgabe« zerlegt:
/ / Noch tut dieses Programm nichts!
/ / Lies die Zahlen a und b ein
/∗ Berechne die Summe beider
Zahlen
∗/
/ / Zeige das Ergebnis auf dem Bildschirm an
int main() {
}
Hier sehen Sie schon ein einfaches C++-Programm. Es bedeuten:
int
ganze Zahl zur Rückgabe
main
Schlüsselwort für Hauptprogramm
()
Innerhalb dieser Klammern können dem Hauptprogramm
Informationen mitgegeben werden.
{ }
Block
/* ... */ Kommentar, der über mehrere Zeilen gehen kann
// ...
Kommentar bis Zeilenende
1
Siehe Glossar Seite 934
31
Register
Symbole
* 47, 184, 393
*= 47, 332
+, += 47
++ 47, 333, 389, 393
+= 47
, 78, 208
-, -= 47
->* 227
-- 47, 336
.* 227
... 302
/ 47
/* ... */ 31
// 31
/= 47
:: 60, 152, 265
::* 227
|| 56
|= 47
! 47, 56
!= 56, 393
; 33, 68
<, <= 47, 56
< 47
<< 47, 96, 218, 318, 367
<<= 47
=, == 47, 56
>, >= 47, 56
>> 47, 94, 218, 371, 711
>>= 47
?: 68
[ ] 188, 189, 322, 323
[ ][ ]
Matrixklasse 358
Zeigerdarstellung 210
# 133
%, %= 47
& Adress-Operator 57
&, &= Bit-Operatoren 47
&& log. UND 56
&& Shell 586
&& R-Wert 578
\ 32, 54, 131
\0 191, 194–196
\", \a, \b 54
\f, \n, \r, \t, \v 54, 94
\x 54
\\ 54
~ 47
ˆ 47
$<, $^, $@ 511
@D, @F 591
" 34, 191, 192
942
Register
A
abgeleitete Klasse 253, 262, 265
und virtueller Destruktor 277
Abhängigkeit (make) 509
automatische Ermittlung 586
abort() 306, 852
abs() 51, 678, 679, 837, 850, 852
abstrakte Klasse 271, 931
Vererbung 271
Abstrakter Datentyp 148, 931
Abstraktion 254
accumulate() 632
acos() 679, 837, 850
acosh() 679
Adapter, Iterator- 785
Additionsoperator 315
adjacent_difference() 636
adjacent_find() 661
adjustfield 369
Adresse 184
symbolische 34
Adressierung
indirekte 844
Adressoperator 185
advance() 784
Aggregation 573, 931
Aktualparameter 104
<algorithm> 609, 789
Algorithmus 28, 389
accumulate() 632
adjacent_difference() 636
adjacent_find() 661
binary_search() 664
copy() 693
copy_backward() 693
copy_if() 695
copy_n() 695
count() 644
count_if() 644
equal() 677
equal_range() 665
fill() 631
fill_n() 631
find() 657
find_end() 661
find_first_of() 658
for_each() 693
generate(), _n() 631
includes() 667
inner_product() 634
inplace_merge() 656
iota() 632
is_heap() 675
iter_swap() 696
lexicographical_compare() 647
lower_bound() 665
make_heap() 674
max() 701
max_element() 637
merge() 653
mergesort() 655
min() 701
min_element() 637
minmax() 701
minmax_element() 638
mismatch() 675
next_permutation() 646
nth_element() 652
partial_sort(), -_copy 651
partial_sum() 635
partition() 648
pop_heap() 672
prev_permutation() 646
push_heap() 673
random_shuffle() 640
remove(), _if(), _copy(), _copy_if()
700
replace(), _if(), _copy(), _copy_if()
698
reverse(), _copy() 643
rotate(), _copy() 639
search() 659
search_n() 662
set_difference() 669
set_intersection() 669
set_symmetric_difference()
set_union() 668
sort() 650
sort_heap() 674
stable_partition() 648
stable_sort() 650
swap() 696
670
Register
swap_ranges() 696
transform() 696
unique(), _copy() 641
upper_bound() 665
Alias-Name 57, 185, 187
*this 223
Alignment 354
allgemeiner Konstruktor 155
allocator 720, 829
Anführungszeichen 34, 191, 192
Anker 402
anonymer Namespace 126
ANSI-Sequenzen zur Bildschirmansteuerung 53
Anweisung 62
any() 777
app 380
append() 817
478,
480
apply() 834
Äquivalenzbeziehung 664
Äquivalenzklasse 516
arg() 678, 679
argc 206
Argumente siehe Parameter
argv[] 206
Arität (Template) 249
Arithmetik mit Iteratoren 392
Arithmetik mit Zeigern 190
arithmetische Operatoren 47
Array
char 193
von C-Strings 197
dynamisches 199, 211, 212, 320
Freigabe 202
als Funktionsparameter 208
mehrdimensionales 207, 211, 212
Matrixklasse 359
valarray 831
vs. Zeiger 188
<array> 738, 754
Array2d 213, 496
ASCII 798
Dateien 218
Tabelle 54, 861
application/x-www-form-urlencoded
asctime() 855
asin() 679, 837, 850
asinh() 679
assert() 134
mit Exception 306
743, 818
Assoziation (UML) 570
Assoziativität von Operatoren 58, 862
at() 83, 87, 745, 749, 755, 758, 817
atan() 679, 837, 850
atan2() 837, 850
atanh() 679
ate 380
atexit() 306, 852
atof(), atoi(), atol() 611, 852
atoi() 626
Atom-Uhr 474
Attribute 150, 932
Aufforderung 29, 932
Aufzählungstyp 80
Ausdruck
Auswertung 58
Definition 44
mathematischer 51, 116
Ausgabe 93, 96, 367
benutzerdefinierter Typen 367
Datei- 96, 365
Formatierung 367
Weite der 368
Ausgabeoperator 318, 367
Ausnahme 932
Ausnahmebehandlung 299
Ausrichtung an Speichergrenzen 354
auto 866
automatische Variable 127
make 511
Autotools (GNU) 600
auto_ptr 823
assign()
B
744, 747, 749, 751, 754
Backslash
Zeichenkonstante \ 54
Zeilenfortsetzung 131
Backspace 54
back_inserter() 786
back()
943
944
Register
back_insert_iterator 786
bad() 379
bad_alloc 304
badbit 378
bad_cast 289, 304
bad_exception 304
bad_typeid 292, 304
base() 785
basefield 369
basic_-Streamklassen 365
basic_string 815
Basisklasse 253
und virtueller Destruktor 277
Konstruktor 283
Subobjekt 286
virtuelle 285
Bedingungsausdruck 66
make 597
Bedingungsoperator ?: 68
beg 381
begin() 394, 740
Belegungsgrad 766
benutzerdefinierte
Datentypen 80, 89
Klassen 318
Typen (Ausgabe) 367
Typen (Eingabe) 711
Benutzungszählung 825
Bereichsnotation 741
Bereichsoperator :: 60, 152, 265
namespace 143
Bibliothek
C++- 718
C- 143, 847
Bibliotheksmodul 125
dynamisch 597
statisch 596
bidirectional_iterator 781
Bildschirmansteuerung mit ANSISequenzen 53
/bin/sh 512
Binärdatei 220
binäre
Ein-/Ausgabe 217
Zahlendarstellung 48
binärer Operator 315
const Rückgabetyp
316
optimiert 580
binäres Prädikat 642, 676, 790
binary 97, 380
binary_function 730
binary_negate 731
binary_search() 664
bind 732
Binden 124
dynamisches siehe dynamisches
Binden
statisches siehe statisches Binden
Bit
Operatoren 47, 48
Verschiebung 48
pro Zahl 44
Bitfelder 90
<bitset> 738
bitset 775
bitweises ODER, UND, XOR 47
Blitz (Matrix) 688
Block 31, 33, 60, 64, 172
und dyn. Objekte 202
bool 56
boolalpha 56, 368, 374
Boost
create_directory() 706
exists() 704
Filesystem 703
is_any_of() 611
is_directory() 704
lexical_cast() 612
Matrix 688
remove_all() 704
split() 611
Boost.Asio 467
break 69, 78
bsearch() 852
Bubble-Sort 83
Bucket 765
bucket() 771, 774
build 507
Byte 53
Byte-Reihenfolge 474
Register
C
C++-Schlüsselwörter 860
C-Arrays 187
C-Funktionen einbinden 145
C-Header 847
C-Header-Datei 143
C-String 191
call wrapper 420
callback-Funktion 222
calloc() 350
capacity() 745, 817
case 69
<cassert> 134, 848
cast siehe Typumwandlung
catch 300
cbegin() 740
<cctype> 697, 848
cdecl 225
ceil() 850
cend() 740
cerr 94, 366
<cerrno> 849
<cfloat> 847
char 53, 190
char* 191
char* const vs. const* char 187
chmod 706
<chrono> 735
cin 34, 94, 366, 379
<ciso646> 847
class (bei Template-Parametern) 136
class 151, 261
clear() 379, 743, 758, 762, 817
Client-Server
Beziehung 152
und callback 222
<climits> 44, 848
<clocale> 848
clock(), clock_t 856
clog 366
close() 97
Closure 870
CMake 603
<cmath> 51, 678, 719, 847, 849
code bloat 603
Code::Blocks 37
805
Code-Formatierer 623
collate 616, 803
combine() 797
compare() 803, 820
Compilationsmodell 604
Compiler 32, 34, 124, 149, 151
-befehle 863
-direktiven 123, 129
und Templates 139
Typumwandlung 164
<complex> 678
Computerarithmetik 51
<concepts> 872
configure 600
conj() 679
connect() 444
const 52
und binäre Operatoren 316
Elementfunktionen 151, 170
globale Konstante 127
const_cast<>() 290
const char* vs. char* const 187
constexpr 867
const_iterator 739
const_local_iterator 771, 774
const_pointer 744
constraint, Vererben von 279
const_reference 739
const_reverse_iterator 742, 785
const& siehe Referenz auf const
Container 389
implizite Datentypen 739
Container-Methoden 740
container_type 749, 751
continue 78
copy semantics 578
copy() 693, 817
copy_backward() 693
copy_if() 695
copy_n() 695
cos(), cosh() 679, 837, 850
count() 759, 770, 774, 777
Algorithmus 644
set 763
count_if() 644
codecvt
945
946
Register
cout 33, 94, 366
__cplusplus 145
crbegin(), crend() 742
create_directory() (Boost.Filesystem) 706
critical section 417
CRLF 478
<csetjmp> 848
cshift() 834
<csignal> 848
<cstdarg> 850
<cstddef> 48, 186, 851
<cstdint> 734
<cstdio> 704, 851
<cstdlib> 116, 221, 719, 849, 851
c_str() 97, 230, 817
<cstring> 192, 223, 229, 231, 853
<ctime> 335, 855
ctype 615, 617, 803, 804
cur 381
curr_symbol 807
<cwctype> 849
CXXFLAGS 511
D
dangling pointer 201
data race 417
data() 744, 755, 817
Datagramm 473
__DATE__ 135
Datei
ASCII 218
binär 220
Ein-/Ausgabe 96, 365
kopieren 97
löschen 704
Öffnungsarten 380
öffnen 97
Positionierung 381
schließen 97
umbenennen 705
Dateizugriffsrechte 706
Daten
als Attributwerte 932
static-Element- 238
Datenbankanbindung 493
Datenkapselung 858, 933
Datensatz 89
Datentypen 34, 43
abstrakte siehe Abstrakter
Datentyp
benutzerdefinierte 80
erster Klasse 295
int und unsigned 552
logische 56
parametrisierte 135, 242
polymorphe 275
strukturierte 89
zusammengesetzte 80
date_order() 810
Datum
gültiges 336
Klasse 334
regulärer Ausdruck 689
dec 368, 374
decimal_point() 806, 807
decltype 867
default 69
default constructor 154
Default-Parameter siehe vorgegebene
Parameter
#define 130, 131
Definition 127, 933
von static-Elementdaten 238
von Objekten 155
Deklaration 33, 34, 37, 127, 933
einer Funktion 103
Funktionszeiger 220
Lesen einer D. 224
in for-Schleifen 75
Deklarationsanweisung 63
Dekrementierung 46, 47
Dekrementoperator 336
Delegation 295
delegierender Konstruktor 181
delete 198, 201, 241, 276, 277
überladen 346
delete [ ] 202, 859
delete Placement-Form 828
= delete 414, 555
<deque> 738
deque 748
Dereferenzierung 184, 221
Register
Design by Contract 311
Destruktor 171, 284, 858
implizite Deklaration 171
und exit() 173, 306
virtueller 276, 859
detach() 415
Dezimalpunkt 49, 806
Dialog 455
difference_type 739
Differenz
Menge 669
symmetrische Menge 670
difftime() 856
digits, digits10 702
distance() 784
Distribution 513, 933
div(), div_t 852
divides 730
dll 597
DNS 465
do while 73
Dokumentation 531
domain_error 304
double 49, 190
als Laufvariable? 77
korrekter Vergleich 551
downcast 289, 328
doxygen 531
Dubletten entfernen 641
Durchschnitt (Menge) 669
dynamic_cast<>() 289
dynamisches Array 320
dynamisches Binden 220, 266, 933
dynamische Datenobjekte 198
dynamischer Typ 291
E
e, E 49
Eclipse 39
effizienter binärer Operator 580
egrep 399, 619
Ein- und Ausgabe 93
Einbinden von C-Funktionen 145
Eingabe 370
Datei- 96, 365
von Strings 95
benutzerdefinierter Typen 711
Einschränkung siehe constraint
Elementdaten, Zeiger auf 228
Elementfunktion 148, 256
Zeiger auf 227
Ellipse 249, 302, 850
else 65
emplace() 742
emplace_back() 745, 747, 749
emplace_front() 747, 749
empty() 740, 750, 751, 753, 817
end 381
end() 394, 740
#endif 131
endl 44, 51, 53, 374
ends 374
ENTER
32, 94
»enthält«-Beziehung 285
enum 80
Enumeration 80
Environment, env[] 206
EOF 372
eof() 301, 372, 379
eofbit 378
epsilon() 702
equal() 677
equalsIgnoreCase() 617
equal_range() 665, 759, 763, 771, 774
equal_to 730
erase() 743, 758, 762, 770, 773, 818
ereignisgesteuerte Programmierung 442
Ergebnisrückgabe 104
errno 298, 704, 849
Exception 932
und Destruktor 300
Handling 299
Hierarchie 303
Speicherleck durch Exc. 557
Spezifikation 302
<exception> 304, 305
exception 303
Exception-Sicherheit 311
exists() (Boost.Filesystem) 704
exit() 116, 306, 852
und Destruktor 173, 306
Exklusiv-Oder (Menge) 670
947
948
Register
exp() 679, 837, 850
explicit 161
explizite Instanziierung von
Templates 606
Exponent 49, 50
export template 607
Expression Template 583
extern 125, 127, 129
extern "C" 145
extern template 605
external linkage 127
F
f, F 49
679, 850
Facette 803
fail() 379, 380
failbit 378, 712
fakultaet() 102
Fallunterscheidung 69
false 56
falsename() 806
Fehlerbehandlung 297
Ein- und Ausgabe 377
Fibonacci 637
__FILE__ 134
fill() 368, 631
fill_n() 631
find() 759, 770, 773
Algorithmus 657
set 763
string 819
find_...-Methoden (string) 820
findstring 597
find_end() 661
find_first_of() 658
fixed 368, 370, 374
Fixture 524
flache Kopie 232
flags() 368
flip() 746, 776
float 49
float.h 49
floatfield 369
floor() 850
flush 374
fabs()
flush() 370
fmod() 850
fmtflags 368
for 75
Kurzform 867
foreach (make) 592
for_each() 693
Formalparameter 104
Formateinstellungen für Streams 368
Formatierung der Ausgabe 367
forward() 725
forward_iterator 781
forward_list 721
frac_digits() 808
Framework 443
free store 198
free() 349
frexp() 850
friend 236
front() 744, 746, 749, 751, 754
front_inserter() 786
front_insert_iterator 786
<fstream> 96
fstream 365, 382
Füllzeichen 368
function 720
<functional> 729
Funktion 102
mit Gedächtnis 105
klassenspezifische 238
mathematische 51, 849
Parameterübergabe
per Referenz 111
per Wert 107
per Zeiger 203
rein virtuelle 271
mit Definition 272
static 238
Überschreiben in abgeleiteten
Klassen 264
Überschreiben virtueller
Funktionen 269, 859
variable Parameterzahl 113
virtuelle siehe virtuelle
Funktionen
Register
vorgegebene Parameterwerte
113
Funktionsobjekte 344, 376
Umwandlung von Zeigern in
Funktionsobjekte 733
Funktionsspezifikation 121
Funktions-Template 135
Funktor siehe Funktionsobjekte, 377
G
g++ 36
Ganzzahlen 44
garbage collection 203
gegenseitige Abhängigkeit von
Klassen 179
Genauigkeit 50
Generalisierung 254
generate(), generate_n() 631
generische Programmierung 388
GET 478
get() 94, 218, 371, 372
get_date() 810
getenv() 852
gethostbyname() 466
getline() für Strings 95, 822
getline(char*,...) 372
getloc() 385
get_monthname() 810
get_temporary_buffer() 829
get_time() 810
get_weekday() 810
get_year() 810
GGT 72
schnell 166
Gleitkommazahl 52
Syntax 48
global 60
Namensraum 143
Variable 125, 129
gmtime() 856
GNU 934
GNU Autotools 600
good() 379
goodbit 378
Grafische Benutzungsschnittstellen 441
greater, greater_equal 730
greedy (regex-Auswertung)
Grenzwerte von Zahltypen
Groß- und Kleinschreibung
größter gemeinsamer Teiler
grouping() 806, 807
gslice 840
gslice_array 843
GTK+ 441
guard 418
Gültigkeitsbereich 115
Block 60
Datei 126
Funktion 104
Klassen 151
und new 201
GUI 441
402
701
32, 37
72
H
hängender Zeiger siehe Zeiger,
hängender
has_facet() 797
hash() 804
Hash-Funktion 765, 767
hasher 768, 772
has_infinity 702
»hat«-Beziehung 573
Header 34
C++-Standard 143
Header (Http) 478
Header-Datei 122, 123
Inhalt 128
Heap 671
hex 368, 374
Hexadezimalzahl 46
Host Byte Order 475
I
iconv 802
IDE 36
Identität von Objekten 150, 934
if 64
#ifdef, #ifndef 130
ifeq 597
ifstream 96, 365
ignore() 372
imag() 678, 679
949
950
Register
imbue() 801
Implementation 123
Implementationsdatei, Inhalt 128
Implementationsvererbung 293
implizite Deklaration
Destruktor 171
Konstruktor 154
Zuweisungsoperator 324, 327
in 97, 380
#include 32, 123, 129
includes() 667
Indexoperator 82, 188, 189, 210, 322,
323
indirect_array 844
indirekte Adressierung 844
infinity() 702
Initialisierung
array 755
und virtuelle Basisklassen 287
C-Array 190, 208
Konstante in Objekten 156, 239
globaler Konstanten 127, 129
mit Liste 156, 239, 259
mit Liste (Container) 741
von Objekten 85, 154, 259
Reihenfolge 156, 231
in for-Schleife 75
von static-Elementdaten 238
und Vererbung 259
von Referenzen 891
und Zuweisung 85, 158
initializer_list 741
Inklusions-Modell 604
Inkrementierung 46, 47
Inkrementoperator 333
inline 140, 152
inner_product() 634
inplace_merge() 656
input_iterator 780
insert() 743, 758, 762, 764, 770, 773,
818
inserter() 787
insert_iterator 786
Installation der DVD-Software 917
Instanz 30, 934
Instanziierung von Templates 244
explizite 606
ökonomische (bei vielen
Dateien) 603
int 33, 44
int-Parameter in Templates 245
int2string() 612
integral promotion 59
Integrierte Entwicklungsumgebungen 37
Interface (UML) 568
internal 368, 374
internal linkage 127
Internet-Anbindung 463
Interrupt (Thread) 424
Intervall 741
Introspektion 443
INT_MAX 44
invalid_argument 304
IOException 562
<iomanip> 374, 375
<ios> 374
ios 365, 377, 379
ios::failure 379
ios_base 365
ios_base-Fehlerstatusbits 378
ios_base-Flags 368, 369
ios_base-Formateinstellungen 368
ios_base-Manipulatoren 374
ios-Flags zur Dateipositionierung
381
ios-Methoden 368, 370, 379
iostate 377
<iostream> 34, 366, 367, 371, 374
ios_base::binary 97
ios_base::in 97
iota() 632
IP-Adresse
regulärer Ausdruck 691
IPv4, IPv6 465
is() 804
isalnum() 802, 849
isalpha() 802, 849
is_any_of() 611
isblank() 849
is_bounded 702
iscntrl() 802, 849
isdigit() 120, 160, 802, 849
Register
is_directory() (Boost.Filesystem)
is_exact 702
isgraph() 802, 849
is_heap(), is_heap_until() 675
is_iec559 702
is_integer 702
islower() 802, 849
is_modulo 702
ISO 10646 799
ISO-8859-1, ISO-8859-15 798
isprint() 802, 849
ispunct() 802
is_signed 702
isspace() 802, 849
ist-ein-Beziehung 253, 263, 278
istream 365, 370
IStream-Iterator 787
istream::seekg(), tellg() 381
istream::ws 374
istringstream 365, 383
isupper() 802, 849
isxdigit() 802, 849
Iterator 389, 393, 779
Adapter 785
Bidirectional 781
Forward 781
Input 780
Insert 786
Kategorie 780
Output 780
Random Access 781
Reverse 785
Stream 787
-Tags 781
Zustand 394
<iterator> 779
iterator 739
iterator_category 780
iter_swap() 696
J
Jahr 855
join() 412, 415
Jota 632
K
Kardinalität 570
704
Kategorie (locale) 803
key_comp() 758, 763
key_compare 757, 761
key_equal 768, 772
key_type 757, 761, 768, 772
Klammerregeln 58
Klasse 29, 149, 934
abgeleitete siehe abgeleitete
Klasse
abstrakte 271
Basis- siehe Basisklasse
Deklaration 151
konkrete 271
Ober- siehe Oberklasse
für einen Ort 150
Unter- siehe Unterklasse
für rationale Zahlen 162
Klassenname 292
klassenspezifische
Daten 238
Funktionen 238
Konstante 241
Klassen-Template 242
Klassifikation 254, 934
Kleinschreibung 32
Kollisionsbehandlung 765
Kommandointerpreter 509, 512
Kommandozeilenparameter 206
Kommaoperator 78, 208
Kommentar 31
komplexe Zahlen 678
Komplexität 939
Komposition 573
konkrete Klasse 271
Konstante 52
globale 127, 129
klassenspezifische 241
konstante Objekte 170, 860
Konstruktor 151, 154
allgemeiner siehe allgemeiner
Konstruktor
implizite Deklaration 154
delegierender 181
Kopier- siehe Kopierkonstruktor
vorgegebene
Parameterwerte 155
951
952
Register
Standard- 154
Typumwandlungs- siehe
Typumwandlungskonstruktor
Kontrollabstraktion 389
Kontrollstrukturen 62
Konvertieren von Datentypen siehe
Typumwandlung
Kopie, flache/tiefe 232
Kopieren
von Dateien 97
von Objekten 232
von Zeichenketten 196
Kopierkonstruktor 158, 322, 858
Objektübergabe 159
Vermeidung des Aufrufs 159
Kreuzreferenzliste 627
kritischer Bereich 417
Kurzform-Operatoren 46
L
l, L 49
L-Wert 63, 188, 193, 322, 935
Übergabe als && 579
Länge eines Vektors 635
Lader 36
Lambda-Funktionen 869
LANG 796
late binding 220
Laufvariable 75, 76
Laufzeit 184
und Funktionszeiger 220
und new 198
und Polymorphie 266
Typinformation 291
ldd 598
ldexp() 850
ldiv(), ldiv_t 852
LD_LIBRARY_PATH 599
left 368, 374
length() 816
length_error 304
lexical_cast() 612
lexicographical_compare() 647
lexikografischer Vergleich 728, 741, 935
<limits> 49, 701
__LINE__ 134
Linken 126, 143
dynamisches 597, 935
internes, externes 127
statisches 596, 935
Linker 36
linksassoziativ 58
lint 68
list 746
<list> 721, 738
Liste
Initialisierungs- 156, 239
Initialisierungs- (bei C-Arrays)
208
Liste (Klasse) 394
Literal 192
Zahlen- 52
Zeichen- 53
load factor 766
load_factor() 771, 774
<locale> 795
localtime() 335, 856
local_iterator 768, 771, 772, 774
lock_guard 418
log(), log10() 679, 837, 850
logical_and, _not, _or 731
logic_error 304
logischer Datentyp 56
logische Fehler 306
logische Negation 56, 57
logisches UND bzw. ODER 57
lokal (Block) 60
lokale Objekte 187
long 44
long double 49
lower_bound() 665, 759, 763
lvalue siehe L-Wert
M
main() 31, 33, 115
MAKE 591
make 507
automatische Ermittlung von
Abhängigkeiten 586
parallelisieren 595
rekursiv 590
Variable 511
Register
Makefile 124, 509
make_heap() 674
make_pair() 728
make_tupel() 729
Makro 131
malloc() 349
Manipulatoren 373
Mantisse 49
<map> 738
map 756
mapped_type 757, 768
mask_array 843
match_results 405
mathematischer Ausdruck 51
mathematische Funktionen 849
Matrix
C-Array 207
C-Array, dynamisch 211
Klasse 213
Klasse, mit zusammenhängendem
Speicher 680
Vektor von Vektoren 358
max() 701, 702, 834
max_bucket_count() 771, 774
max_element() 637
max_exponent, max_exponent10 702
max_load_factor() 771, 774
max_size() 740
mehrdimensionales Array 207
mehrdimensionale Matrizen 358
Mehrfachvererbung 255, 281, 284
MeinString (Klasse) 229
member function siehe Elementfunktion
memchr() 854
memcmp(), memcpy(), memmove(), 854
mem_fn 720
mem_fun(), mem_fun_ref() 734
<memory> 721, 829
memory leak 202, 557
memset() 855
Mengenoperationen auf sortierten
Strukturen 667
merge() 653, 747
mergesort() 655
messages 803, 812
Meta-Objekt-Compiler 444
Methode 30, 148, 936
Regeln zur Konstruktion
von Prototypen 547
MIME 936
min() 701, 702, 834
min_element() 637
min_exponent, min_exponent10 702
MinGW 508
minmax() 701
minmax_element() 638
minus 730
Minute 855
mischen 653
mismatch() 675
mkdir() 706
mktime() 856
modf() 850
modulare Gestaltung 122
Modulo 47
modulus 730
Monat 855
monetary 803, 807
money_get 808
moneypunct 807
money_put 809
Monitor 429
move semantics 578
move() 724
moving constructor 578
M_PI 344, 678, 710
multimap 760
multiplies 730
Multiplikationsoperator 332
Multiplizität (UML) 570
multiset 764
mutable 170
N
Nachbedingung 121, 936
Nachkommastellen 49
precision 710
Name 37
einer Klasse 292
name() 292, 797
named return value optimization 577
953
954
Register
Namenskonflikte bei Mehrfachvererbung 284
Namenskonventionen 36
Nameserver 465
Namespace
anonym 126
in Header-Dateien 134
Verzeichnisstruktur 589
namespace 32, 142
namespace std 61, 143
narrow() 805
nationale Sprachumgebung 796
NDEBUG 134, 306
negate 730
Negation
bitweise 47, 48
logische 56, 57
Negationsoperator (überladen) 380
negative_sign() 808
neg_format() 808
Network Byte Order 475
Netzwerkprogrammierung 463
neue Zeile 51, 54, 64
new 198, 201, 241
Fehlerbehandlung 308
überladen 346
<new> 304, 828
new Placement-Form 828
new_handler 308
next_permutation() 646
noboolalpha 374
none() 777
norm() 678, 679
noshowbase, -point, -pos 374
noskipws 374
not1, not2 731
Notation für Intervalle 741
not_equal_to 730
nothrow 310
notify_one(), _all() 423, 564
nounitbuf, nouppercase 374
npos 816
NRVO 577
nth_element() 652
NULL 186, 851
und new 310
nullptr 186, 870
numeric 803, 805
numeric_limits 49, 701
numerische Auslöschung 50
num_get, num_put 805
NummeriertesObjekt
Klasse 238
806
numpunct
O
O-Notation 939
Oberklasse 253, 264, 936
erben von 256
Subobjekt einer 259
Subtyp einer 262
Zugriffsrechte vererben 260
Oberklassenkonstruktor 256, 259
Objekt 28, 149, 151, 936
dynamisches 198
-erzeugung 151
als Funktions- 344
-hierarchie 285
Identität siehe Identität von
Objekten
Initialisierung 154, 259
konstantes 170, 860
-orientierung 147
temporäres 161
Übergabe per Wert 159
verkettete Objekte 200
verwitwetes 202
vollständiges 286, 287, 939
Objektcode 36
oct 368, 374
ODER
bitweises 47
logisches 57
Öffnungsarten für Streams 380
offsetof 851
ofstream 96, 365
Oktalzahl 46
omanip 375
one definition rule 128, 858
open() 96
OpenMP 566
Open Source 937
Register
Operator
arithmetischer 47
binärer 315
const Rückgabetyp 316
Bit- 47
für char 55
als Funktion 314
Kurzform 47
für logische Datentypen 56
Präzedenz 58, 862
relationale 47, 56, 723
Syntax 314
Typumwandlungs- 337
überladen (<<) 367
überladen (>>) 711
unärer 315
für ganze Zahlen 46
operator!() 380
operator delete() 346
operator new() 346
operator string() 338
operator()() 344
operator*() 333, 339, 393
operator*=() 332
operator++() 333, 335, 393
operator++(int) 553
operator+=() 317
operator->() 339
operator|() 775
operator|=() 776
operator!=() 393, 777
operator<<() 318, 367, 775, 776
operator<<=() 776
operator=() 325
operator==() 393, 777
operator>>() 371, 775, 776
operator>>=() 776
operator[]()
323, 361, 364, 744, 749,
755, 781
operator&() 775
operator&=() 776
operatorˆ=() 776
operatorˆ() 775
operator~() 776
Optimierung durch Vermeiden
temporärer Objekte 159
Ort (Klasse) 150
ostream 318, 365, 367
OStream-Iterator 787
ostream::endl, ends, flush() 374
ostream::seekp(), tellp() 381
ostringstream 365, 383
out 380
out_of_range 304
output_iterator 780
overflow 46, 50
overflow_error 304
P
727
paralleler Ablauf (make) 595
Parameter einer Funktion 103
Parameterübergabe
per Referenz 111
per Wert 107
per Zeiger 203
parametrisierte Datentypen 135, 242
»part-of«-Beziehung 573
partial_sort(), -_copy 651
partial_sum() 635
partielle Spezialisierung von
Templates 780
partition() 648
patsubst 513
peek() 372
perfect forwarding 579, 725
Performance 575
Permutationen 646
PHONY 510
π 52, 678
Placement new/delete 828
plus 730
POD (plain old data type) 937
pointer 744, 757, 761, 768, 772
Pointer, smarte 339
polar() 679
polymorpher Typ 275, 291
Polymorphismus 266, 937
pop() 750, 751, 753
pop_back() 745, 747, 749
pop_front() 747, 749
pop_heap() 672
pair
955
956
Register
portabel 800
808
Positionierung innerhalb einer Datei 381
positive_sign() 808
POSIX 796
POST 483
postcondition siehe Nachbedingung
Postfix-Operator 333
pos_type 381
pow() 679, 837
Prädikat
Algorithmus mit P. 790
binäres 642, 676, 790
unäres 644
Präfix-Operator 333
Präprozessor 123, 129, 586
Präzedenz von Operatoren 58, 862
precision() 370
precondition siehe Vorbedingung
prev_permutation() 646
PRINT (Makro) 133
printf() 249
Priority-Queue 752
private 151, 260
private Vererbung 293
Programm
ausführbares 36
Strukturierung 101
Programmierrichtlinien 858
Projekte 125
protected 260
protected-Vererbung 295
Prototyp
Funktions- 102
einer Methode 150
Regeln zur Konstruktion
547
ptrdiff_t 851
ptr_fun() 733
public 151, 256, 260
push() 750, 751, 753
push_back() 745, 747, 749
vector 86
push_front() 747, 749
push_heap() 673
put() 96, 218, 367
pos_format()
372
putback()
Q
qsort()
221, 852
Qt 443
cout 445
QThread 459
Quantifizierer 402
Queue 751
<queue> 721, 738, 751
quicksort() 136
R
R-Wert 63, 188, 935
Referenz 578
race condition 417, 438
radix 702
RAII 386, 418, 524, 558, 937
rand() 692, 852
Random 692
random_access_iterator 781
random_shuffle() 640
RAND_MAX 852
range_error 304
<ratio> 734
rationale Zahlen (Klasse) 162
raw_storage_iterator 829
rbegin() 742, 785, 816
rdstate() 379
read() 217
real() 678, 679
realloc() 350
Rechengenauigkeit 49, 77
rechtsassoziativ 58
reelle Zahlen 48
reentrant 438
ref(), reference_wrapper 420, 735
reference
bitset
775
Container 739
vector<bool> 745
reference collapsing 579
reference counting 825
reference_wrapper 735
Referenz 57, 119
auf Basisklasse 269
Register
auf const 111, 158
auf istream 371, 711
auf Oberklasse 262, 268
auf ostream 318, 367
Parameterübergabe per 111
Rückgabe per 323
auf R-Wert 578
oder Zeiger? 859
Referenzsemantik 232, 575
<regex> 304, 406
regex_iterator 405
regex_match() 407
regex_replace() 408, 621
regex_search() 407, 619
register 127
reguläre Ausdrücke 399
Reihenfolge
Auswertungs- 58
Berechnungs- 51
der Initialisierung 156, 231
umdrehen 643
rein virtuelle Funktion 271
mit Definition 272
reinterpret_cast<>() 217, 291
Rekursion 108
Template-Metaprogrammierung 248,
251
rekursiver Abstieg 116, 117
rekursiver Make-Aufruf 590
relationale Operatoren 47, 56, 723
rel_ops 723
remove()
Algorithmus 700
Datei/Verzeichnis (C) 704
Liste 747
remove_all() (Boost.Filesystem) 704
remove_if() 700, 747
rename() Datei/Verzeichnis (C) 705
rend() 742, 785, 816
replace() 698, 819
replace_copy() ,replace_if(),
replace_copy_if() 698
reserve() 234, 745, 816
reset() 776
resetiosflags() 374
resize() 745, 747, 749, 816
return 34, 159
return_temporary_buffer()
reverse() (list) 747
reverse(), _copy() 643
829
Reverse-Iterator 785
reverse_iterator 742
Reversible Container 742
rfind() 819
right 368, 374
rotate(), rotate_copy() 639
round_error(), _style() 702
RTTI 291
runtime_error 304
rvalue siehe R-Wert
S
scan_is(), scan_not()
804
Schleifen 71
do while
for 75
73
und Strings 194
Tabellensuche 85
-terminierung 72
while 71
Schlüsselwörter 860
Schnittmenge 669
Schnittstelle 123, 938
einer Funktion 106
Regeln zur Konstruktion
547
scientific 368, 370, 374
scope 60
scoped locking 418
search() 659
search_n() 662
sed 594
seekg(), seekp() 381
Seiteneffekt 66, 103, 195, 197
im Makro 135
Seitenvorschub 54
Sekunde 855
Selektion 64
sentinel 85, 190
sentry 386
Sequenz 64
Sequenz-Methoden 743
957
958
Register
Server-Client
Beziehung 152
und callback 222
<set> 738
set 761
set() 776
setbase() 374
set_difference() 669
setf() 368, 369
setfill() 374
set_intersection() 669
setiosflags() 374
setjmp() 848
setprecision() 374
setstate() 379
set_symmetric_difference() 670
set_terminate(), set_unexpected()
set_union() 668
set_new_handler() 309
setw() 374
shared_ptr 344, 825
306
für Arrays 558
SHELL 512
shift() 834
short 44
showbase, showpoint, showpos
showSequence() 630
shrink_to_fit() 235, 816
840
Slot 444, 447
Smart Pointer 339
und Exceptions 557
Socket 468
Sommerzeit 855
Sonderzeichen 54
sort() 650
Sortieren 650
stabiles 650
durch Verschmelzen 654
Sortierung 221
sort_heap() 674
Speicherklasse 125
Speicherleck 202, 557
Speicherplatzfreigabe 186
Speicherverwaltung (eigene) 353
Spezialisierung
von Klassen 254
von Templates 138
Spezifikation einer Funktion 121
splice() 748
split() 610
Sprachumgebung 796
SQL 493
sqrt() 51, 679, 837, 850
srand() 692, 852
SSH 538
<sstream> 383
stable_partition() 648
stable_sort() 650
Stack 60
Klasse 242
<stack> 721, 738
stack 749
stack unwinding 300
Standard
-bibliothek
C 143, 847
C++ 718
Ein-/Ausgabe 94
-header 144, 721
-klassen 721
-Typumwandlungen 59
Zeiger 226
start() 838, 841
slice_array
368, 374
Sichtbarkeit 60
dateiübergreifend 125
Sichtbarkeitsbereich (namespace) 142
Signal 444, 447
Signalton 54
Signatur 114, 256, 265, 266, 269
signed char 53
sin(), sinh() 679, 837, 850
single entry/ single exit 79
size() 82, 87, 740
sizeof 189
nicht bei dynamischen Arrays 212
size_t 48, 851
size_type 739
Skalarprodukt 634
skipws 368, 374
sleep() 414
slice 838
Register
125, 126
Elementdaten 238
Elementfunktion 238
in Funktion 105
Makefile 596
static_assert 135, 870
static_cast<>() 54, 288
statisches Binden 266, 938
Statusabfrage einer Datei 379
std 32, 61, 143
<stdexcept> 304
stdio 368
Stelligkeit (Template) 249
STL 387
strcat(), strchr(), strcmp() 853
strncat(), strncmp() 854
strpbrk(), strrchr(), strstr() 854
strcpy() 197, 853
strcspn() 853
stream 365
Stream-Iterator 787
Stream-Öffnungsarten 380
strerror() 704, 849, 853
Streuspeicherung 765
strftime() 856
stride() 838, 841
String 87
string 87, 815
append() 817
assign() 818
at() 87, 817
begin() 816
capacity() 817
clear() 817
compare() 820
copy() 817
c_str() 817
data() 817
empty() 817
end() 816
erase() 818
find() 819
find_...-Methoden 820
insert() 818
length() 87, 816
operator+=() 817
static
rbegin(), rend() 816
replace() 819
reserve() 816
resize() 816
rfind() 819
shrink_to_fit() 816
size() 87, 816
substr() 820
swap() 817
verketten 87
721, 815
string.h 192
String-Klasse MeinString 229
Stringlänge 194, 195
Stringliteral 799
strlen() 192, 195, 853
strncpy() 563, 854
strtod(), strtol(), strtoul() 611, 852
strtok() 626, 854
struct 89, 261
Strukturanalyse 535
Stunde 855
Subobjekt 256, 262, 283
in virtuellen Basisklassen 285
verschiedene 284
Substitutionsprinzip 278
substr() 820
Subtyp 257, 262, 278, 938
Subversion 536
Suffix 49
sum() 834
swap() 740, 817
Algorithmus 696
swap_ranges() 696
switch 69
symmetrische Differenz
sortierter Strukturen 670
Synchronisation 416
Syntaxdiagramm 117, 119
?: Bedingungsoperator 68
do while-Schleife 73
enum-Deklaration 80
for-Schleife 75
Funktionsaufruf 104
Funktionsdefinition 103
Funktionsprototyp 103
<string>
959
960
Register
Funktions-Template 136
if-Anweisung 65
mathematischer Ausdruck 117
operator-Deklaration 314
struct-Definition 89
switch-Anweisung 69
Typumwandlungsoperator 338
while-Schleife 71
system() 852
system_error 304, 379
T
Tabellensuche 85
Tabulator 54
Tag 855
tan(), tanh() 679, 837, 850
target (make) 509
Taschenrechnersimulation 116
Tastaturabfrage 94
TCP 464
»Teil-Ganzes«-Beziehung 573
tellg(), tellp() 381
Template
für Funktionen 135
#include 139
Instanziierung von T. 244
explizite 606
ökonomische (bei vielen
Dateien) 603
int-Parameter 245
für Klassen 242
Spezialisierung 138
partielle 780
staticstatic Attribut 356
variable Parameterzahl 249, 685
Template-Metaprogrammierung 247
temporäres Objekt 161
Vermeidung 159
terminate() 305
terminate_handler 305
Test Driven Development 517
test() 777
Test-Suite 519
Textersetzung 131
this 223
this->, *this bei Zugriff auf
Oberklassenelement 332
this_thread 412
thousands_sep() 806, 807
Thread 409
genau einer pro Objekt 424
thread (API) 413
Thread-Sicherheit 438
thread_group 416, 418
throw 300
tie() 385
tiefe Kopie 232
__TIME__ 135
time 803, 810
time() 335, 856
time_get 810
time_put 811
time_t 335, 855
tm 335, 855
tolower() 615, 802, 805, 848
top() 750, 753
to_string() 777
to_ulong() 777
toupper() 615, 800, 802, 804, 848
TR1 28
traits 779
transform() 696, 804
tree (Programm) 588, 708
Trennung von Schnittstellen und
Implementation 125, 858
true 56
truename() 806
trunc 380
try 300
Tupel, <tuple> 729
tuple_cat() 686
Typ 938
polymorpher bzw. dynamischer
Typ 291
type cast siehe Typumwandlung
<type_traits> 872
typedef 224
typeid() 291
<typeinfo> 304
typename (bei Template-Parametern) 136
type_info 291
Register
Typinformation 276
zur Laufzeit 291
Typumwandlung
cast 54, 186, 221, 288
cast-Schreibweise 55
durch Compiler 164
const_cast<>() 290
dynamic_cast<>() 289
mit explicit 161
implizit 161, 552
mit Informationsverlust 115
-skonstruktor 160, 164, 315
-soperator 337
ios 380
reinterpret_cast<>() 291
Standard- 59
Zeiger 226
static_cast<>() 288
U
UDP 464, 473
Überladen
von Funktionen 114
von Operatoren siehe operator
Überlauf 46, 50
Überschreiben
von Funktionen in
abgeleiteten Klassen 264
virtueller Funktionen 269, 859
Übersetzung 123, 124
-seinheit 127
Umgebungsvariable 206
UML 253, 567
Umleitung der Ausgabe auf Strings 383
unärer Operator 315
unäres Prädikat 644
unary_function 730
unary_negate 731
uncaught_exception() 305
UND
bitweises 47, 48
logisches 57
#undef 131
undefined behaviour 203
underflow 51
underflow_error 304
unexpected() 305
unexpected_handler
305
Unicode 365, 798
uninitialized_copy() 829
uninitialized_fill(), _n() 830
union 90
unique() 641, 747
unique_copy() 641
unique_lock 418
unique_ptr 823
Unit-Test 515
unitbuf 368, 370, 374
unordered_map 767
unordered_multimap 771
unordered_multiset 774
unordered_set 772
unsigned 44
unsigned char 53
Unterklasse 253, 939
uppercase 368, 374
upper_bound() 665, 759, 763
URI, URL 464, 621
URL-Codierung 478
use_facet() 615–617, 797
using
-Deklaration 294
Klassen 292
Namespace
Deklaration 143
Direktive 142
UTC 856
UTF-8 798
<utility> 724, 728
V
Valarray
arithmetische Operatoren 835
Bit-Operatoren 835
logische Operatoren 836
mathematische Funktionen 837
relationale Operatoren 836
<valarray> 831
value_comp() 758, 763
value_compare 757, 761
value_type 739, 757, 761, 768
Variable 34
961
962
Register
automatische 127
globale 125, 129
make 511
Variablenname 36
variadic templates 249, 685
vector
at() 83
push_back() 86
size() 82
<vector> 721, 738
vector 744
vector<bool> 745
Vektor 82
Klasse 319
Länge eines 635
Verbundanweisung 64
Vereinigung (Menge) 668
Vererbung 939
der abstrakt-Eigenschaft einer
Klasse 271
von constraints 279
der Implementierung 294
Mehrfach- 281
private 293
protected 295
von Zugriffsrechten 260
und Zuweisungsoperator 326
Vergleich von double-Werten 551
verschmelzen (merge) 653
Versionskontrolle 536
Vertrag 122, 279, 939
verwitwetes Objekt 202
Verzeichnis
anlegen 706
anzeigen 707
-baum (make) 589
-baum anzeigen 708
löschen 704
umbenennen 705
Verzweigung 64
virtual 266, 268, 277
virtuelle Basisklasse 285
virtueller Destruktor 276
virtuelle Funktionen 266, 269
rein- 271
void 186
als Funktionstyp 103
221
Typumwandlung nach 186
Typumwandlungsoperator 380
vollständiges Objekt 286, 287, 939
Vorbedingung 121, 939
vorgegebene Parameterwerte
in Funktionen 113
in Konstruktoren 155
Vorkommastellen 49
Vorrangregeln 58, 862
Vorwärtsdeklaration 179
void*
W
Wächter (Tabellenende) 85, 190
Wahrheitswert 56
wait() 422, 430
Warteschlange 751
wchar_t 53, 799, 851
wcstombs() 801
weak_ptr 827
Webserver 483
Weite der Ausgabe 368
Wert
eines Attributs 932
Parameterübergabe per 107
Wertebereich 45
Wertsemantik 232, 389, 575
Performanceproblem 577
what() 304
while 71, 194, 196
whitespace siehe Zwischenraumzeichen
wide character 53
widen() 805
Widget 447
width() 368
Wiederverwendung
durch Delegation 295
durch Vererbung 263
wildcard 513
Winterzeit 855
Wochentag 855
wofstream 801
Worttrennung 32
Wrapperklasse für Iterator 785
Register
write() 217, 367
ws 374
wstring 801, 815
X
XOR, bitweises 47
Y
yield()
414
Z
Zahlenbereich 44, 49
Zeichen 53
Zeichenkette 34, siehe auch string
C-String 191
-konstante 191
Kopieren einer 195
Zeichenklasse 402
Zeichenkonstante 53
Zeichenliteral 798
Zeichensatz 798
Zeiger 183, 198
-arithmetik 190
vs. Array 188
auf Basisklasse 269, 276
-darstellung
von [ ] 189
von [ ][ ] 210
auf Elementdaten 228
auf Elementfunktionen 227, 733
auf Funktionen 220
hängender 201
intelligente siehe Smart Pointer
in Klassen 858
Null-Zeiger 186
auf Oberklasse 262, 268
auf ein Objekt (Mehrfachvererbung)
284
auf lokale Objekte 187
Parameterübergabe per 203
oder Referenz? 859
Umwandlung in Funktionsobjekte 733
Zeile
einlesen siehe getline()
neue 54
Zeitkomplexität 939
Zerlegung 648
Ziel (make) 509
Ziffernzeichen 53
Zufallszahlen 692
Zugriffsspezifizierer und -rechte 260
zusammengesetzte Datentypen 80
Zusicherung 134, 306
Zustand 940
eines Iterators 394
Zuweisung 34, 63, 67, 940
in abgeleiteten Klassen 262
und Initialisierung 85, 158
Zuweisungsoperator 158, 324, 858
implizite Deklaration 324, 327
und Vererbung 326
zweidimensionale Matrix 680
Zweierkomplement 44
Zwischenraumzeichen 94, 193, 371
963