Die C++-Programmiersprache - aktuell zum C++11-Standard
von: Bjarne Stroustrup
Carl Hanser Fachbuchverlag, 2015
ISBN: 9783446439818
Sprache: Deutsch
1467 Seiten, Download: 11352 KB
Format: PDF, auch als Online-Lesen
Inhalt | 6 | ||
Vorwort | 32 | ||
Teil I Einführung | 36 | ||
1 Vorbemerkungen | 38 | ||
1.1?Zum Aufbau dieses Buchs | 38 | ||
1.1.1?Einführung | 39 | ||
1.1.2?Grundlegende Sprachmittel | 39 | ||
1.1.3?Abstraktionsmechanismen | 40 | ||
1.1.4?Die Standardbibliothek | 42 | ||
1.1.5?Beispiele und Referenzen | 43 | ||
1.2?Der Entwurf von C++ | 45 | ||
1.2.1?Programmierstile | 47 | ||
1.2.2?Typprüfung | 50 | ||
1.2.3?C-Kompatibilität | 51 | ||
1.2.4?Sprache, Bibliotheken und Systeme | 52 | ||
1.3?C++ lernen | 54 | ||
1.3.1?In C++ programmieren | 56 | ||
1.3.2?Ratschläge für C++-Programmierer | 57 | ||
1.3.3?Ratschläge für C-Programmierer | 58 | ||
1.3.4?Ratschläge für Java-Programmierer | 59 | ||
1.4?Historische Anmerkungen | 60 | ||
1.4.1?Chronik | 61 | ||
1.4.2?Die frühen Jahre | 62 | ||
1.4.2.1?Sprachfeatures und Bibliotheksinstrumente | 63 | ||
1.4.3?Der 1998-Standard | 65 | ||
1.4.3.1?Sprachfeatures | 65 | ||
1.4.3.2?Die Standardbibliothek | 66 | ||
1.4.4?Der 2011-Standard | 67 | ||
1.4.4.1?Sprachfeatures | 68 | ||
1.4.4.2?Standardbibliothek | 69 | ||
1.4.5?Wofür wird C++ verwendet? | 70 | ||
1.5?Ratschläge | 72 | ||
1.6?Literaturhinweise | 73 | ||
2 Ein Rundreise durch C++: Die Grundlagen | 78 | ||
2.1?Einführung | 78 | ||
2.2?Die Grundlagen | 79 | ||
2.2.1?Hello, World! | 79 | ||
2.2.2?Typen, Variablen und Arithmetik | 81 | ||
2.2.3?Konstanten | 83 | ||
2.2.4?Tests und Schleifen | 84 | ||
2.2.5?Zeiger, Arrays und Schleifen | 86 | ||
2.3?Benutzerdefinierte Typen | 88 | ||
2.3.1?Strukturen | 88 | ||
2.3.2?Klassen | 90 | ||
2.3.3?Aufzählungen | 92 | ||
2.4?Modularität | 93 | ||
2.4.1?Separate Kompilierung | 94 | ||
2.4.2?Namespaces | 95 | ||
2.4.3?Fehlerbehandlung | 96 | ||
2.4.3.1?Ausnahmen | 97 | ||
2.4.3.2?Invarianten | 98 | ||
2.4.3.3?Statische Assertionen | 99 | ||
2.5?Nachbemerkung | 100 | ||
2.6?Ratschläge | 100 | ||
3 Eine Rundreise durch C++: Abstraktionsmechanismen | 102 | ||
3.1?Einführung | 102 | ||
3.2?Klassen | 103 | ||
3.2.1?Konkrete Typen | 103 | ||
3.2.1.1?Ein arithmetischer Typ | 104 | ||
3.2.1.2?Ein Container | 106 | ||
3.2.1.3?Container initialisieren | 107 | ||
3.2.2?Abstrakte Typen | 108 | ||
3.2.3?Virtuelle Funktionen | 111 | ||
3.2.4?Klassenhierarchien | 112 | ||
3.3?Kopieren und verschieben | 116 | ||
3.3.1?Container kopieren | 116 | ||
3.3.2?Container verschieben | 118 | ||
3.3.3?Ressourcenverwaltung | 120 | ||
3.3.4?Operationen unterdrücken | 121 | ||
3.4?Templates | 122 | ||
3.4.1?Parametrisierte Typen | 122 | ||
3.4.2?Funktions-Templates | 123 | ||
3.4.3?Funktionsobjekte | 124 | ||
3.4.4?Variadische Templates | 127 | ||
3.4.5?Alias | 128 | ||
3.5?Ratschläge | 129 | ||
4 Eine Rundreise durch C++: Container und Algorithmen | 130 | ||
4.1?Bibliotheken | 130 | ||
4.1.1?Überblick über die Standardbibliothek | 131 | ||
4.1.2?Header und Namespace der Standardbibliothek | 132 | ||
4.2?Strings | 133 | ||
4.3?Stream-Ein-/Ausgabe | 135 | ||
4.3.1?Ausgabe | 135 | ||
4.3.2?Eingabe | 136 | ||
4.3.3?Ein-/Ausgabe von benutzerdefinierten Typen | 137 | ||
4.4?Container | 139 | ||
4.4.1?vector | 139 | ||
4.4.1.1?Elemente | 141 | ||
4.4.1.2?Bereichsüberprüfung | 141 | ||
4.4.2?list | 142 | ||
4.4.3?map | 144 | ||
4.4.4?unordered_map | 145 | ||
4.4.5?Überblick über Container | 145 | ||
4.5?Algorithmen | 147 | ||
4.5.1?Iteratoren verwenden | 148 | ||
4.5.2?Iteratortypen | 150 | ||
4.5.3?Stream-Iteratoren | 151 | ||
4.5.4?Prädikate | 153 | ||
4.5.5?Überblick über Algorithmen | 153 | ||
4.5.6?Containeralgorithmen | 154 | ||
4.6?Ratschläge | 155 | ||
5 Eine Rundreise durch C++: Nebenläufigkeit und Dienstprogramme | 156 | ||
5.1?Einführung | 156 | ||
5.2?Ressourcenverwaltung | 156 | ||
5.2.1?unique_ptr und shared_ptr | 157 | ||
5.3?Nebenläufigkeit | 159 | ||
5.3.1?Tasks und Threads | 160 | ||
5.3.2?Argumente übergeben | 161 | ||
5.3.3?Ergebnisse zurückgeben | 162 | ||
5.3.4?Daten gemeinsam nutzen | 162 | ||
5.3.4.1?Warten auf Ereignisse | 164 | ||
5.3.5?Kommunizierende Tasks | 165 | ||
5.3.5.1?future und promise | 166 | ||
5.3.5.2?packaged_task | 167 | ||
5.3.5.3?async() | 168 | ||
5.4?Kleine Hilfskomponenten | 169 | ||
5.4.1?Zeit | 169 | ||
5.4.2?Typfunktionen | 170 | ||
5.4.2.1?iterator_traits | 170 | ||
5.4.2.2?Typprädikate | 172 | ||
5.4.3?pair und tuple | 173 | ||
5.5?Reguläre Ausdrücke | 174 | ||
5.6?Mathematik | 175 | ||
5.6.1?Mathematische Funktionen und Algorithmen | 175 | ||
5.6.2?Komplexe Zahlen | 175 | ||
5.6.3?Zufallszahlen | 176 | ||
5.6.4?Vektorarithmetik | 178 | ||
5.6.5?Numerische Grenzen | 179 | ||
5.7?Ratschläge | 179 | ||
Teil II Grundlegende Sprachelemente | 180 | ||
6 Typen und Deklarationen | 182 | ||
6.1?Der ISO-C++-Standard | 182 | ||
6.1.1?Implementierungen | 184 | ||
6.1.2?Der grundlegende Quellzeichensatz | 184 | ||
6.2?Typen | 185 | ||
6.2.1?Fundamentale Typen | 185 | ||
6.2.2?Boolesche Typen | 186 | ||
6.2.3?Zeichentypen | 188 | ||
6.2.3.1?Vorzeichenbehaftete und vorzeichenlose Zeichen | 190 | ||
6.2.3.2?Zeichenliterale | 191 | ||
6.2.4?Ganzzahltypen | 193 | ||
6.2.4.1?Ganzzahlliterale | 193 | ||
6.2.4.2?Typen von Ganzzahlliteralen | 194 | ||
6.2.5?Gleitkommatypen | 195 | ||
6.2.5.1?Gleitkommaliterale | 195 | ||
6.2.6?Präfixe und Suffixe | 196 | ||
6.2.7?void | 197 | ||
6.2.8?Größen | 197 | ||
6.2.9?Ausrichtung | 200 | ||
6.3?Deklarationen | 201 | ||
6.3.1?Die Struktur von Deklarationen | 203 | ||
6.3.2?Mehrere Namen deklarieren | 204 | ||
6.3.3?Namen | 205 | ||
6.3.3.1?Schlüsselwörter | 206 | ||
6.3.4?Gültigkeitsbereiche | 207 | ||
6.3.5?Initialisierung | 209 | ||
6.3.5.1?Fehlende Initialisierer | 212 | ||
6.3.5.2?Initialisierungslisten | 213 | ||
6.3.6?Einen Typ herleiten: auto und decltype() | 214 | ||
6.3.6.1?Der Typspezifizierer auto | 214 | ||
6.3.6.2?auto und {}-Listen | 215 | ||
6.3.6.3?Der Spezifizierer decltype() | 216 | ||
6.4?Objekte und Werte | 217 | ||
6.4.1?L-Werte und R-Werte | 217 | ||
6.4.2?Lebensdauer von Objekten | 218 | ||
6.5?Typalias | 219 | ||
6.6?Ratschläge | 220 | ||
7 Zeiger, Arrays und Referenzen | 222 | ||
7.1?Einführung | 222 | ||
7.2?Zeiger | 222 | ||
7.2.1?void* | 223 | ||
7.2.2?nullptr | 224 | ||
7.3?Arrays | 225 | ||
7.3.1?Array-Initialisierer | 226 | ||
7.3.2?Stringliterale | 227 | ||
7.3.2.1?Rohe Zeichen-Strings | 229 | ||
7.3.2.2?Größere Zeichensätze | 230 | ||
7.4?Zeiger auf Arrays | 231 | ||
7.4.1?Navigieren in Arrays | 233 | ||
7.4.2?Mehrdimensionale Arrays | 235 | ||
7.4.3?Arrays übergeben | 236 | ||
7.5?Zeiger und const | 238 | ||
7.6?Zeiger und Besitz | 240 | ||
7.7?Referenzen | 241 | ||
7.7.1?L-Wert-Referenzen | 243 | ||
7.7.2?R-Wert-Referenzen | 246 | ||
7.7.3?Referenzen auf Referenzen | 249 | ||
7.7.4?Zeiger und Referenzen | 250 | ||
7.8?Ratschläge | 252 | ||
8 Strukturen, Unions und Aufzählungen | 254 | ||
8.1?Einführung | 254 | ||
8.2?Strukturen | 254 | ||
8.2.1?Layout einer Struktur | 256 | ||
8.2.2?Namen von Strukturen | 257 | ||
8.2.3?Strukturen und Klassen | 259 | ||
8.2.4?Strukturen und Arrays | 260 | ||
8.2.5?Typäquivalenz | 262 | ||
8.2.6?Plain Old Data | 263 | ||
8.2.7?Felder | 265 | ||
8.3?Unions | 266 | ||
8.3.1?Unions und Klassen | 268 | ||
8.3.2?Anonyme Unions | 269 | ||
8.4?Aufzählungen | 272 | ||
8.4.1?Aufzählungsklassen | 272 | ||
8.4.2?Einfache Aufzählungen | 276 | ||
8.4.3?Unbenannte Aufzählungen | 278 | ||
8.5?Ratschläge | 278 | ||
9 Anweisungen | 280 | ||
9.1?Einführung | 280 | ||
9.2?Zusammenfassung der Anweisungen | 280 | ||
9.3?Deklarationen als Anweisungen | 282 | ||
9.4?Auswahlanweisungen | 283 | ||
9.4.1?if-Anweisungen | 283 | ||
9.4.2?switch-Anweisungen | 285 | ||
9.4.2.1?Deklarationen in case-Zweigen | 287 | ||
9.4.3?Deklarationen in Bedingungen | 287 | ||
9.5?Schleifenanweisungen | 288 | ||
9.5.1?Bereichsbasierte for-Anweisungen | 289 | ||
9.5.2?for-Anweisungen | 290 | ||
9.5.3?while-Anweisungen | 291 | ||
9.5.4?do-Anweisungen | 292 | ||
9.5.5?Schleifen verlassen | 292 | ||
9.6?goto-Anweisungen | 293 | ||
9.7?Kommentare und Einrückungen | 294 | ||
9.8?Ratschläge | 296 | ||
10 Ausdrücke | 298 | ||
10.1?Einführung | 298 | ||
10.2?Ein Taschenrechner | 298 | ||
10.2.1?Der Parser | 299 | ||
10.2.2?Eingabe | 303 | ||
10.2.3?Low-level-Eingabe | 307 | ||
10.2.4?Fehlerbehandlung | 309 | ||
10.2.5?Das Rahmenprogramm | 309 | ||
10.2.6?Header | 310 | ||
10.2.7?Befehlszeilenargumente | 311 | ||
10.2.8?Eine Anmerkung zum Stil | 312 | ||
10.3?Zusammenfassung der Operatoren | 313 | ||
10.3.1?Ergebnisse | 317 | ||
10.3.2?Reihenfolge der Auswertung | 318 | ||
10.3.3?Operatorrangfolge | 319 | ||
10.3.4?Temporäre Objekte | 320 | ||
10.4?Konstante Ausdrücke | 322 | ||
10.4.1?Symbolische Konstanten | 324 | ||
10.4.2?const-Typen in konstanten Ausdrücken | 325 | ||
10.4.3?Literale Typen | 325 | ||
10.4.4?Referenzargumente | 326 | ||
10.4.5?Adresse konstanter Ausdrücke | 327 | ||
10.5?Implizite Typkonvertierung | 327 | ||
10.5.1?Heraufstufungen | 328 | ||
10.5.2?Konvertierungen | 328 | ||
10.5.2.1?Integrale Konvertierungen | 329 | ||
10.5.2.2?Gleitkommakonvertierungen | 329 | ||
10.5.2.3?Zeiger- und Referenzkonvertierungen | 330 | ||
10.5.2.4?Zeiger-auf-Member-Konvertierungen | 330 | ||
10.5.2.5?Boolesche Konvertierungen | 330 | ||
10.5.2.6?Gleitkomma-Ganzzahl-Konvertierungen | 331 | ||
10.5.3?Übliche arithmetische Konvertierungen | 332 | ||
10.6?Ratschläge | 332 | ||
11 Auswahloperationen | 334 | ||
11.1?Diverse Operatoren | 334 | ||
11.1.1?Logische Operatoren | 334 | ||
11.1.2?Bitweise logische Operatoren | 334 | ||
11.1.3?Bedingte Ausdrücke | 336 | ||
11.1.4?Inkrementieren und Dekrementieren | 336 | ||
11.2?Freispeicher | 338 | ||
11.2.1?Speicherverwaltung | 340 | ||
11.2.2?Arrays | 343 | ||
11.2.3?Speicherplatz beschaffen | 344 | ||
11.2.4?Überladen von new | 345 | ||
11.2.4.1?nothrow new | 347 | ||
11.3?Listen | 348 | ||
11.3.1?Implementierungsmodell | 348 | ||
11.3.2?Qualifizierte Listen | 350 | ||
11.3.3?Unqualifizierte Listen | 350 | ||
11.4?Lambda-Ausdrücke | 352 | ||
11.4.1?Implementierungsmodelle | 353 | ||
11.4.2?Alternativen für Lambda-Ausdrücke | 354 | ||
11.4.3?Erfassung | 356 | ||
11.4.3.1?Lambda und Lebensdauer | 358 | ||
11.4.3.2?Namen von Namespaces | 359 | ||
11.4.3.3?Lambda und this | 359 | ||
11.4.3.4?Veränderbare Lambda-Ausdrücke | 359 | ||
11.4.4?Aufruf und Rückgabe | 360 | ||
11.4.5?Der Typ eines Lambda-Ausdrucks | 360 | ||
11.5?Explizite Typumwandlung | 361 | ||
11.5.1?Konstruktion | 363 | ||
11.5.2?Benannte Typumwandlungen | 364 | ||
11.5.3?C-Typumwandlungen | 366 | ||
11.5.4?Funktionale Typumwandlung | 366 | ||
11.6?Ratschläge | 367 | ||
12 Funktionen | 368 | ||
12.1?Funktionsdeklarationen | 368 | ||
12.1.1?Warum Funktionen? | 369 | ||
12.1.2?Bestandteile einer Funktionsdeklaration | 369 | ||
12.1.3?Funktionsdefinitionen | 370 | ||
12.1.4?Werte zurückgeben | 372 | ||
12.1.5?Inline-Funktionen | 374 | ||
12.1.6?constexpr-Funktionen | 375 | ||
12.1.6.1?constexpr und Referenzen | 376 | ||
12.1.6.2?Bedingte Auswertung | 377 | ||
12.1.7?[[noreturn]]-Funktionen | 377 | ||
12.1.8?Lokale Variablen | 378 | ||
12.2?Argumentübergabe | 379 | ||
12.2.1?Referenzargumente | 380 | ||
12.2.2?Array-Argumente | 382 | ||
12.2.3?Listenargumente | 384 | ||
12.2.4?Nicht angegebene Anzahl von Argumenten | 385 | ||
12.2.5?Standardargumente | 389 | ||
12.3?Überladene Funktionen | 391 | ||
12.3.1?Automatische Auflösung von Überladungen | 391 | ||
12.3.2?Überladen und Rückgabetyp | 393 | ||
12.3.3?Überladen und Gültigkeitsbereiche | 394 | ||
12.3.4?Auflösung für mehrere Argumente | 395 | ||
12.3.5?Manuelle Auflösung von Überladungen | 395 | ||
12.4?Vor- und Nachbedingungen | 396 | ||
12.5?Zeiger auf Funktion | 398 | ||
12.6?Makros | 402 | ||
12.6.1?Bedingte Übersetzung | 405 | ||
12.6.2?Vordefinierte Makros | 406 | ||
12.6.3?Pragmas | 407 | ||
12.7?Ratschläge | 407 | ||
13 Ausnahmenbehandlung | 410 | ||
13.1?Fehlerbehandlung | 410 | ||
13.1.1?Ausnahmen | 411 | ||
13.1.2?Herkömmliche Fehlerbehandlung | 413 | ||
13.1.3?Durchhangeln | 414 | ||
13.1.4?Alternative Ansichten von Ausnahmen | 415 | ||
13.1.4.1?Asynchrone Ereignisse | 415 | ||
13.1.4.2?Ausnahmen, die keine Fehler sind | 415 | ||
13.1.5?Wann Sie keine Ausnahmen verwenden können | 416 | ||
13.1.6?Hierarchische Fehlerbehandlung | 417 | ||
13.1.7?Ausnahmen und Effizienz | 419 | ||
13.2?Ausnahmegarantien | 421 | ||
13.3?Ressourcenverwaltung | 423 | ||
13.3.1?finally | 426 | ||
13.4?Invarianten erzwingen | 428 | ||
13.5?Ausnahmen auslösen und abfangen | 433 | ||
13.5.1?Ausnahmen auslösen | 433 | ||
13.5.1.1?noexcept-Funktionen | 435 | ||
13.5.1.2?Der Operator noexcept | 435 | ||
13.5.1.3?Ausnahmespezifikationen | 436 | ||
13.5.2?Ausnahmen abfangen | 437 | ||
13.5.2.1?Ausnahmen erneut auslösen | 438 | ||
13.5.2.2?Jede Ausnahme abfangen | 439 | ||
13.5.2.3?Mehrere Handler | 440 | ||
13.5.2.4?try-Blöcke in Funktionen | 440 | ||
13.5.2.5?Beendigung | 442 | ||
13.5.3?Ausnahmen und Threads | 444 | ||
13.6?Eine vector-Implementierung | 445 | ||
13.6.1?Ein einfacher vector | 445 | ||
13.6.2?Speicher explizit darstellen | 449 | ||
13.6.3?Zuweisung | 452 | ||
13.6.4?Größe ändern | 454 | ||
13.6.4.1?reserve() | 455 | ||
13.6.4.2?resize() | 456 | ||
13.6.4.3?push_back() | 456 | ||
13.6.4.4?Abschließende Gedanken | 457 | ||
13.7?Ratschläge | 458 | ||
14 Namespaces | 460 | ||
14.1?Kompositionsprobleme | 460 | ||
14.2?Namespaces | 461 | ||
14.2.1?Explizite Qualifizierung | 463 | ||
14.2.2?using-Deklarationen | 464 | ||
14.2.3?using-Direktiven | 465 | ||
14.2.4?Argumentabhängige Namensauflösung | 466 | ||
14.2.5?Namespaces sind offen | 469 | ||
14.3?Modularisierung und Schnittstellen | 470 | ||
14.3.1?Namespaces als Module | 471 | ||
14.3.2?Implementierungen | 473 | ||
14.3.3?Schnittstellen und Implementierungen | 475 | ||
14.4?Komposition mit Namespaces | 477 | ||
14.4.1?Komfort vs. Sicherheit | 477 | ||
14.4.2?Namespace-Alias | 478 | ||
14.4.3?Namespaces zusammensetzen | 479 | ||
14.4.4?Komposition und Auswahl | 480 | ||
14.4.5?Namespaces und Überladen | 481 | ||
14.4.6?Versionsverwaltung | 483 | ||
14.4.7?Verschachtelte Namespaces | 485 | ||
14.4.8?Unbenannte Namespaces | 486 | ||
14.4.9?C-Header | 487 | ||
14.5?Ratschläge | 488 | ||
15 Quelldateien und Programme | 490 | ||
15.1?Separate Übersetzung | 490 | ||
15.2?Binden | 491 | ||
15.2.1?Dateilokale Namen | 494 | ||
15.2.2?Header-Dateien | 495 | ||
15.2.3?Die Eine-Definition-Regel | 497 | ||
15.2.4?Header der Standardbibliothek | 499 | ||
15.2.5?Binden mit Nicht-C++-Code | 500 | ||
15.2.6?Binden und Zeiger auf Funktionen | 502 | ||
15.3?Header-Dateien verwenden | 503 | ||
15.3.1?Organisation mit einzelnem Header | 503 | ||
15.3.2?Organisation mit mehreren Header-Dateien | 507 | ||
15.3.2.1?Andere Taschenrechnermodule | 510 | ||
15.3.2.2?Header verwenden | 512 | ||
15.3.3?Include-Wächter | 513 | ||
15.4?Programme | 514 | ||
15.4.1?Initialisierung von nichtlokalen Variablen | 514 | ||
15.4.2?Initialisierung und Nebenläufigkeit | 515 | ||
15.4.3?Programmbeendigung | 516 | ||
15.5?Ratschläge | 518 | ||
Teil III Abstraktionsmechanismen | 520 | ||
16 Klassen | 522 | ||
16.1?Einführung | 522 | ||
16.2?Grundlagen von Klassen | 523 | ||
16.2.1?Member-Funktionen | 524 | ||
16.2.2?Standardmäßiges Kopieren | 525 | ||
16.2.3?Zugriffskontrolle | 526 | ||
16.2.4?class und struct | 527 | ||
16.2.5?Konstruktoren | 529 | ||
16.2.6?Explizite Konstruktoren | 531 | ||
16.2.7?Klasseninterne Initialisierer | 533 | ||
16.2.8?Klasseninterne Funktionsdefinitionen | 534 | ||
16.2.9?Veränderlichkeit | 535 | ||
16.2.9.1?Konstante Member-Funktionen | 535 | ||
16.2.9.2?Physische und logische Konstanz | 536 | ||
16.2.9.3?mutable | 537 | ||
16.2.9.4?Veränderlichkeit über Indirektion | 537 | ||
16.2.10?Selbstreferenz | 538 | ||
16.2.11?Member-Zugriff | 540 | ||
16.2.12?Statische Member | 541 | ||
16.2.13?Member-Typen | 543 | ||
16.3?Konkrete Klassen | 544 | ||
16.3.1?Member-Funktionen | 547 | ||
16.3.2?Hilfsfunktionen | 550 | ||
16.3.3?Überladene Operatoren | 551 | ||
16.3.4?Der Stellenwert von konkreten Klassen | 552 | ||
16.4?Ratschläge | 553 | ||
17 Konstruieren, Aufräumen, Kopieren und Verschieben | 556 | ||
17.1?Einführung | 556 | ||
17.2?Konstruktoren und Destruktoren | 558 | ||
17.2.1?Konstruktoren und Invarianten | 559 | ||
17.2.2?Destruktoren und Ressourcen | 560 | ||
17.2.3?Basis- und Member-Destruktoren | 561 | ||
17.2.4?Konstruktoren und Destruktoren aufrufen | 562 | ||
17.2.5?Virtuelle Destruktoren | 563 | ||
17.3?Initialisierung von Klassenobjekten | 564 | ||
17.3.1?Initialisierung ohne Konstruktoren | 564 | ||
17.3.2?Initialisierung mithilfe von Konstruktoren | 566 | ||
17.3.2.1?Initialisierung durch Konstruktoren | 568 | ||
17.3.3?Standardkonstruktoren | 569 | ||
17.3.4?Initialisierungslisten-Konstruktoren | 571 | ||
17.3.4.1?Mehrdeutigkeiten bei Initialisierungslisten-Konstruktoren auflösen | 572 | ||
17.3.4.2?Initialisierungslisten verwenden | 573 | ||
17.3.4.3?Direkte und Kopierinitialisierung | 574 | ||
17.4 Initialisierung von Membern und Basisklassen | 576 | ||
17.4.1?Member-Initialisierung | 576 | ||
17.4.1.1?Member-Initialisierung und -Zuweisung | 577 | ||
17.4.2?Basisklassen-Initialisierer | 578 | ||
17.4.3?Konstruktoren delegieren | 578 | ||
17.4.4?Klasseninterne Initialisierer | 579 | ||
17.4.5?Initialisierer statischer Member | 581 | ||
17.5?Kopieren und verschieben | 582 | ||
17.5.1?Kopieren | 583 | ||
17.5.1.1?Vorsicht vor Standardkonstruktoren | 585 | ||
17.5.1.2?Kopieren von Basisklassen | 585 | ||
17.5.1.3?Was Kopieren bedeutet | 586 | ||
17.5.1.4?Slicing | 589 | ||
17.5.2?Verschieben | 590 | ||
17.6?Standardoperationen generieren | 594 | ||
17.6.1?Explizite Standardoperationen | 595 | ||
17.6.2?Standardoperationen | 596 | ||
17.6.3?Standardoperationen verwenden | 597 | ||
17.6.3.1?Standardkonstruktoren | 597 | ||
17.6.3.2?Invarianten bewahren | 597 | ||
17.6.3.3?Ressourceninvarianten | 598 | ||
17.6.3.4?Partiell spezifizierte Invarianten | 599 | ||
17.6.4?Gelöschte Funktionen | 601 | ||
17.7?Ratschläge | 603 | ||
18 Überladen von Operatoren | 606 | ||
18.1?Einführung | 606 | ||
18.2?Operatorfunktionen | 608 | ||
18.2.1?Binäre und unäre Operatoren | 609 | ||
18.2.2?Vordefinierte Bedeutungen für Operatoren | 610 | ||
18.2.3?Operatoren und benutzerdefinierte Typen | 611 | ||
18.2.4?Objekte übergeben | 611 | ||
18.2.5?Operatoren in Namespaces | 613 | ||
18.3?Ein Typ für komplexe Zahlen | 615 | ||
18.3.1?Member- und Nicht-Member-Operatoren | 615 | ||
18.3.2?Arithmetik mit gemischten Datentypen | 616 | ||
18.3.3?Konvertierungen | 617 | ||
18.3.3.1?Konvertierung von Operanden | 619 | ||
18.3.4?Literale | 620 | ||
18.3.5?Zugriffsfunktionen | 621 | ||
18.3.6?Hilfsfunktionen | 622 | ||
18.4?Typumwandlung | 623 | ||
18.4.1?Konvertierungsoperatoren | 623 | ||
18.4.2?Explizite Konvertierungsoperatoren | 625 | ||
18.4.3?Mehrdeutigkeiten | 626 | ||
18.5?Ratschläge | 628 | ||
19 Spezielle Operatoren | 630 | ||
19.1?Einführung | 630 | ||
19.2?Spezielle Operatoren | 630 | ||
19.2.1?Indizierung | 630 | ||
19.2.2?Funktionsaufruf | 631 | ||
19.2.3?Dereferenzieren | 633 | ||
19.2.4?Inkrementieren und Dekrementieren | 635 | ||
19.2.5?Allokation und Deallokation | 637 | ||
19.2.6?Benutzerdefinierte Literale | 639 | ||
19.3?Eine String-Klasse | 642 | ||
19.3.1?Wesentliche Operationen | 643 | ||
19.3.2?Zugriff auf Zeichen | 643 | ||
19.3.3?Darstellung | 644 | ||
19.3.3.1?Ergänzende Funktionen | 646 | ||
19.3.4?Member-Funktionen | 647 | ||
19.3.5?Hilfsfunktionen | 650 | ||
19.3.6?Unsere String-Klasse verwenden | 652 | ||
19.4?Friends | 652 | ||
19.4.1?Friends finden | 654 | ||
19.4.2?Friends und Member | 655 | ||
19.5?Ratschläge | 657 | ||
20 Abgeleitete Klassen | 660 | ||
20.1?Einführung | 660 | ||
20.2?Abgeleitete Klassen | 661 | ||
20.2.1?Member-Funktionen | 664 | ||
20.2.2?Konstruktoren und Destruktoren | 665 | ||
20.3?Klassenhierarchien | 666 | ||
20.3.1?Typfelder | 666 | ||
20.3.2?Virtuelle Funktionen | 669 | ||
20.3.3?Explizite Qualifizierung | 672 | ||
20.3.4?Überschreiben steuern | 672 | ||
20.3.4.1?override | 674 | ||
20.3.4.2?final | 675 | ||
20.3.5?Member der Basisklasse verwenden | 677 | ||
20.3.5.1?Konstruktoren vererben | 678 | ||
20.3.6?Lockerung bei Rückgabetypen | 680 | ||
20.4?Abstrakte Klassen | 682 | ||
20.5?Zugriffskontrolle | 684 | ||
20.5.1?Geschützte Member | 688 | ||
20.5.1.1?Geschützte Member verwenden | 689 | ||
20.5.2?Zugriff auf Basisklassen | 689 | ||
20.5.2.1?Mehrfachvererbung und Zugriffskontrolle | 690 | ||
20.5.3?using-Deklarationen und Zugriffskontrolle | 691 | ||
20.6?Zeiger auf Member | 692 | ||
20.6.1?Zeiger auf Funktions-Member | 692 | ||
20.6.2?Zeiger auf Daten-Member | 694 | ||
20.6.3?Basis- und abgeleitete Member | 695 | ||
20.7?Ratschläge | 696 | ||
21 Klassenhierarchien | 698 | ||
21.1?Einführung | 698 | ||
21.2?Klassenhierarchien entwerfen | 698 | ||
21.2.1?Implementierungsvererbung | 699 | ||
21.2.1.1?Kritische Betrachtungen | 702 | ||
21.2.2?Schnittstellenvererbung | 703 | ||
21.2.3?Alternative Implementierungen | 705 | ||
21.2.3.1?Kritische Betrachtungen | 708 | ||
21.2.4?Objekterstellung örtlich begrenzen | 709 | ||
21.3?Mehrfachvererbung | 710 | ||
21.3.1?Mehrfachschnittstellen | 711 | ||
21.3.2?Mehrere Implementierungsklassen | 711 | ||
21.3.3?Auflösung von Mehrdeutigkeiten | 713 | ||
21.3.4?Eine Basisklasse wiederholt verwenden | 717 | ||
21.3.5?Virtuelle Basisklassen | 718 | ||
21.3.5.1?Virtuelle Basisklassen konstruieren | 721 | ||
21.3.5.2?Member einer virtuellen Klasse nur einmal aufrufen | 722 | ||
21.3.6?Replizierte und virtuelle Basisklassen | 724 | ||
21.3.6.1?Funktionen virtueller Basisklassen überschreiben | 726 | ||
21.4?Ratschläge | 727 | ||
22 Laufzeit-Typinformationen | 728 | ||
22.1?Einführung | 728 | ||
22.2?Navigation in der Klassenhierarchie | 728 | ||
22.2.1?dynamic_cast | 730 | ||
22.2.1.1?dynamic_cast in Referenz | 732 | ||
22.2.2?Mehrfachvererbung | 733 | ||
22.2.3?static_cast und dynamic_cast | 735 | ||
22.2.4?Eine Schnittstelle zurückgewinnen | 736 | ||
22.3?Doppelte Bindung und Besucher | 740 | ||
22.3.1?Doppelte Bindung | 741 | ||
22.3.2?Besucher | 743 | ||
22.4?Konstruktion und Destruktion | 745 | ||
22.5?Typidentifizierung | 746 | ||
22.5.1?Erweiterte Typinformationen | 748 | ||
22.6?RTTI – richtig und falsch eingesetzt | 749 | ||
22.7?Ratschläge | 751 | ||
23 Templates | 754 | ||
23.1?Einführung und Überblick | 754 | ||
23.2?Ein einfaches String-Template | 757 | ||
23.2.1?Ein Template definieren | 759 | ||
23.2.2?Template-Instanziierung | 760 | ||
23.3?Typprüfung | 761 | ||
23.3.1?Typäquivalenz | 763 | ||
23.3.2?Fehlererkennung | 764 | ||
23.4?Member von Klassen-Templates | 765 | ||
23.4.1?Daten-Member | 765 | ||
23.4.2?Member-Funktionen | 766 | ||
23.4.3?Member-Typalias | 766 | ||
23.4.4?Statische Member | 767 | ||
23.4.5?Member-Typen | 767 | ||
23.4.6?Member-Templates | 768 | ||
23.4.6.1?Templates und Konstruktoren | 769 | ||
23.4.6.2?Templates und virtual | 770 | ||
23.4.6.3?Verschachtelungen | 770 | ||
23.4.7?Friends | 773 | ||
23.5?Funktions-Templates | 774 | ||
23.5.1?Argumente von Funktions-Templates | 776 | ||
23.5.2?Funktions-Template-Argumente herleiten | 777 | ||
23.5.2.1?Referenzherleitung | 778 | ||
23.5.3?Überladen von Funktions-Templates | 780 | ||
23.5.3.1?Mehrdeutigkeiten auflösen | 781 | ||
23.5.3.2?Fehler bei Argumentersetzung | 782 | ||
23.5.3.3?Überladen und Ableitung | 784 | ||
23.5.3.4?Überladen und nicht hergeleitete Parameter | 784 | ||
23.6?Template-Alias | 785 | ||
23.7?Quellcodeorganisation | 786 | ||
23.7.1?Binden | 788 | ||
23.8?Ratschläge | 789 | ||
24 Generische Programmierung | 792 | ||
24.1?Einführung | 792 | ||
24.2?Algorithmen und Lifting | 793 | ||
24.3?Konzepte | 797 | ||
24.3.1?Ein Konzept erkennen | 798 | ||
24.3.2?Konzepte und Einschränkungen | 801 | ||
24.4?Konzepte konkret machen | 803 | ||
24.4.1?Axiome | 807 | ||
24.4.2?Konzepte mit mehreren Argumenten | 808 | ||
24.4.3?Wertkonzepte | 810 | ||
24.4.4?Einschränkungsüberprüfungen | 810 | ||
24.4.5?Überprüfung von Template-Definitionen | 812 | ||
24.5?Ratschläge | 814 | ||
25 Spezialisierung | 816 | ||
25.1?Einführung | 816 | ||
25.2?Template-Parameter und -Argumente | 817 | ||
25.2.1?Typen als Argumente | 817 | ||
25.2.2?Werte als Argumente | 819 | ||
25.2.3?Operationen als Argumente | 821 | ||
25.2.4?Templates als Argumente | 823 | ||
25.2.5?Template-Standardargumente | 824 | ||
25.2.5.1?Standardargumente bei Funktions-Templates | 825 | ||
25.3?Spezialisierung | 826 | ||
25.3.1?Schnittstellenspezialisierung | 829 | ||
25.3.1.1?Implementierungsspezialisierung | 830 | ||
25.3.2?Das primäre Template | 830 | ||
25.3.3?Reihenfolge der Spezialisierung | 832 | ||
25.3.4?Funktions-Template-Spezialisierung | 833 | ||
25.3.4.1?Spezialisierung und Überladen | 833 | ||
25.3.4.2?Spezialisierung, die kein Überladen ist | 834 | ||
25.4?Ratschläge | 835 | ||
26 Instanziierung | 836 | ||
26.1?Einführung | 836 | ||
26.2?Template-Instanziierung | 837 | ||
26.2.1?Wann wird Instanziierung gebraucht? | 838 | ||
26.2.2?Manuelle Kontrolle der Instanziierung | 839 | ||
26.3?Namensbindung | 840 | ||
26.3.1?Abhängige Namen | 842 | ||
26.3.2?Bindung am Punkt der Definition | 844 | ||
26.3.3?Bindung am Punkt der Instanziierung | 845 | ||
26.3.4?Mehrere Punkte der Instanziierung | 847 | ||
26.3.5?Templates und Namespaces | 849 | ||
26.3.6?Zu aggressive ADL | 850 | ||
26.3.7?Namen aus Basisklassen | 852 | ||
26.4?Ratschläge | 854 | ||
27 Templates und Hierarchien | 856 | ||
27.1?Einführung | 856 | ||
27.2?Parametrisierung und Hierarchie | 857 | ||
27.2.1?Generierte Typen | 859 | ||
27.2.2?Template-Konvertierungen | 861 | ||
27.3?Hierarchien von Klassen-Templates | 862 | ||
27.3.1?Templates als Schnittstellen | 864 | ||
27.4?Template-Parameter als Basisklassen | 864 | ||
27.4.1?Datenstrukturen zusammensetzen | 865 | ||
27.4.2?Klassenhierarchien linearisieren | 869 | ||
27.5?Ratschläge | 874 | ||
28 Metaprogrammierung | 876 | ||
28.1?Einführung | 876 | ||
28.2?Typfunktionen | 878 | ||
28.2.1?Typalias | 881 | ||
28.2.1.1?Wann man keinen Alias verwendet | 882 | ||
28.2.2?Typprädikate | 883 | ||
28.2.3?Eine Funktion auswählen | 885 | ||
28.2.4?Traits | 885 | ||
28.3?Steuerungsstrukturen | 887 | ||
28.3.1?Auswahl | 887 | ||
28.3.1.1?Zwischen zwei Typen auswählen | 888 | ||
28.3.1.2?Übersetzungszeit versus Laufzeit | 888 | ||
28.3.1.3?Zwischen mehreren Typen auswählen | 890 | ||
28.3.2?Iteration und Rekursion | 891 | ||
28.3.2.1?Rekursion mit Klassen | 892 | ||
28.3.3?Wann man Metaprogrammierung verwendet | 892 | ||
28.4?Bedingte Definition: Enable_if | 894 | ||
28.4.1?Enable_if verwenden | 895 | ||
28.4.2?Enable_if implementieren | 897 | ||
28.4.3?Enable_if und Konzepte | 898 | ||
28.4.4?Weitere Beispiele mit Enable_if | 898 | ||
28.5?Eine Liste zur Übersetzungszeit: Tuple | 901 | ||
28.5.1?Eine einfache Ausgabefunktion | 903 | ||
28.5.2?Elementzugriff | 904 | ||
28.5.2.1?Konstante Tupel | 906 | ||
28.5.3?make_tuple | 907 | ||
28.6?Variadische Templates | 908 | ||
28.6.1?Eine typsichere printf()-Funktion | 908 | ||
28.6.2?Technische Details | 911 | ||
28.6.3?Weiterleitung | 913 | ||
28.6.4?Der Typ tuple der Standardbibliothek | 914 | ||
28.7?Beispiel: SI-Einheiten | 918 | ||
28.7.1?Einheiten | 918 | ||
28.7.2?Größen | 919 | ||
28.7.3?Literale für Einheiten | 921 | ||
28.7.4?Hilfsfunktionen | 923 | ||
28.8?Ratschläge | 924 | ||
29 Ein Matrix-Design | 926 | ||
29.1?Einführung | 926 | ||
29.1.1?Einfache Anwendungen von Matrix | 926 | ||
29.1.2?Anforderungen an Matrix | 928 | ||
29.2?Ein Matrix-Template | 929 | ||
29.2.1?Konstruktion und Zuweisung | 931 | ||
29.2.2?Indizierung und Slicing | 932 | ||
29.3?Arithmetische Matrix-Operationen | 935 | ||
29.3.1?Skalaroperationen | 936 | ||
29.3.2?Addition | 936 | ||
29.3.3?Multiplikation | 938 | ||
29.4?Matrix-Implementierung | 940 | ||
29.4.1?slice() | 940 | ||
29.4.2?Matrix-Slices | 940 | ||
29.4.3?Matrix_ref | 942 | ||
29.4.4?Matrix-Listeninitialisierung | 943 | ||
29.4.5?Matrix-Zugriff | 945 | ||
29.4.6?Nulldimensionale Matrix | 948 | ||
29.5?Lineare Gleichungen lösen | 949 | ||
29.5.1?Das klassische gaußsche Eliminationsverfahren | 950 | ||
29.5.2?Pivotisierung | 951 | ||
29.5.3?Testen | 952 | ||
29.5.4?Verschmolzene Operationen | 953 | ||
29.6?Ratschläge | 956 | ||
Teil IVDie Standardbibliothek | 958 | ||
30 Überblick über die Standardbibliothek | 960 | ||
30.1?Einführung | 960 | ||
30.1.1?Komponenten der Standardbibliothek | 961 | ||
30.1.2?Designeinschränkungen | 962 | ||
30.1.3?Beschreibungsstil | 964 | ||
30.2?Header | 964 | ||
30.3?Sprachunterstützung | 969 | ||
30.3.1?Unterstützung für Initialisierungslisten | 969 | ||
30.3.2?Unterstützung für bereichsbasierte for-Anweisung | 970 | ||
30.4?Fehlerbehandlung | 970 | ||
30.4.1?Ausnahmen | 971 | ||
30.4.1.1?Die Hierarchie der Standardausnahmen | 972 | ||
30.4.1.2?Weiterleitung von Ausnahmen | 973 | ||
30.4.1.3?terminate() | 976 | ||
30.4.2?Assertionen | 976 | ||
30.4.3?system_error | 977 | ||
30.4.3.1?Fehlercodes | 978 | ||
30.4.3.2?Fehlerkategorien | 980 | ||
30.4.3.3?system_error-Ausnahme | 981 | ||
30.4.3.4?Potenziell portable Fehlerbedingungen | 982 | ||
30.4.3.5?Fehlercodes zuordnen | 982 | ||
30.4.3.6?errc-Fehlercodes | 984 | ||
30.4.3.7?future_errc-Fehlercodes | 987 | ||
30.4.3.8?io_errc-Fehlercodes | 987 | ||
30.5?Ratschläge | 987 | ||
31 STL-Container | 990 | ||
31.1?Einführung | 990 | ||
31.2?Überblick über Container | 990 | ||
31.2.1?Containerdarstellung | 993 | ||
31.2.2?Anforderungen an die Elemente | 995 | ||
31.2.2.1?Vergleiche | 996 | ||
31.2.2.2?Andere relationale Operatoren | 997 | ||
31.3?Operatoren im Überblick | 998 | ||
31.3.1?Member-Typen | 1001 | ||
31.3.2?Konstruktoren, Destruktor und Zuweisungen | 1002 | ||
31.3.3?Größe und Kapazität | 1004 | ||
31.3.4?Iteratoren | 1004 | ||
31.3.5?Elementzugriff | 1006 | ||
31.3.6?Stack-Operationen | 1006 | ||
31.3.7?Listenoperationen | 1007 | ||
31.3.8?Andere Operationen | 1008 | ||
31.4?Container | 1009 | ||
31.4.1?vector | 1009 | ||
31.4.1.1?vector und Wachstum | 1009 | ||
31.4.1.2?vector und Verschachtelung | 1011 | ||
31.4.1.3?vector und Arrays | 1013 | ||
31.4.1.4?vector und string | 1013 | ||
31.4.2?Listen | 1014 | ||
31.4.3?Assoziative Container | 1016 | ||
31.4.3.1?Geordnete assoziative Container | 1017 | ||
31.4.3.2?Ungeordnete assoziative Container | 1021 | ||
31.4.3.3?Ungeordnete Maps konstruieren | 1022 | ||
31.4.3.4?Hash- und Gleichheitsfunktionen | 1024 | ||
31.4.3.5?Lastfaktor und Buckets | 1027 | ||
31.5?Containeradapter | 1028 | ||
31.5.1?stack | 1029 | ||
31.5.2?queue | 1031 | ||
31.5.3?priority_queue | 1031 | ||
31.6?Ratschläge | 1032 | ||
32 STL-Algorithmen | 1036 | ||
32.1?Einführung | 1036 | ||
32.2?Algorithmen | 1036 | ||
32.2.1?Sequenzen | 1037 | ||
32.3?Richtlinienargumente | 1038 | ||
32.3.1?Komplexität | 1040 | ||
32.4 Nichtmodifizierende Sequenzalgorithmen | 1041 | ||
32.4.1?for_each() | 1041 | ||
32.4.2?Sequenzprädikate | 1041 | ||
32.4.3?count() | 1042 | ||
32.4.4?find() | 1042 | ||
32.4.5?equal() und mismatch() | 1043 | ||
32.4.6?search() | 1044 | ||
32.5?Modifizierende Sequenzalgorithmen | 1045 | ||
32.5.1?copy() | 1046 | ||
32.5.2?unique() | 1047 | ||
32.5.3?remove(), reverse() und replace() | 1048 | ||
32.5.4?rotate(), random_shuffle() und partition() | 1049 | ||
32.5.5?Permutationen | 1050 | ||
32.5.6?fill() | 1051 | ||
32.5.7?swap() | 1052 | ||
32.6?Sortieren und Suchen | 1053 | ||
32.6.1?Binäre Suche | 1056 | ||
32.6.2?merge() | 1057 | ||
32.6.3?Mengenalgorithmen | 1058 | ||
32.6.4?Heaps | 1059 | ||
32.6.5?lexicographical_compare() | 1061 | ||
32.7?Minimum und Maximum | 1061 | ||
32.8?Ratschläge | 1063 | ||
33 STL-Iteratoren | 1064 | ||
33.1?Einführung | 1064 | ||
33.1.1?Iteratormodell | 1064 | ||
33.1.2?Iteratorkategorien | 1066 | ||
33.1.3?Iterator-Traits | 1067 | ||
33.1.4?Iteratoroperationen | 1070 | ||
33.2?Iteratoradapter | 1071 | ||
33.2.1?Reverse-Iteratoren | 1071 | ||
33.2.2?Einfügeiteratoren | 1074 | ||
33.2.3?Verschiebeiteratoren | 1075 | ||
33.3?Bereichszugriffsfunktionen | 1076 | ||
33.4?Funktionsobjekte | 1077 | ||
33.5?Funktionsadapter | 1078 | ||
33.5.1?bind() | 1079 | ||
33.5.2?mem_fn() | 1081 | ||
33.5.3?function | 1081 | ||
33.6?Ratschläge | 1084 | ||
34 Speicher und Ressourcen | 1086 | ||
34.1?Einführung | 1086 | ||
34.2?„Beinahe-Container“ | 1086 | ||
34.2.1?array | 1087 | ||
34.2.2?bitset | 1090 | ||
34.2.2.1?Konstruktoren | 1091 | ||
34.2.2.2?bitset-Operationen | 1093 | ||
34.2.3?vector |
1095 | ||
34.2.4?Tupel | 1096 | ||
34.2.4.1?pair | 1096 | ||
34.2.4.2?tuple | 1098 | ||
34.3?Ressourcenverwaltungszeiger | 1100 | ||
34.3.1?unique_ptr | 1101 | ||
34.3.2?shared_ptr | 1104 | ||
34.3.3?weak_ptr | 1108 | ||
34.4?Allokatoren | 1111 | ||
34.4.1?Der Standard-Allokator | 1112 | ||
34.4.2?Allokator-Traits | 1114 | ||
34.4.3?Zeiger-Traits | 1115 | ||
34.4.4?Allokatoren mit eigenem Gültigkeitsbereich | 1115 | ||
34.5?Die Schnittstelle zur Garbage Collection | 1117 | ||
34.6?Nichtinitialisierter Speicher | 1120 | ||
34.6.1?Temporäre Puffer | 1121 | ||
34.6.2?raw_storage_iterator | 1121 | ||
34.7?Ratschläge | 1123 | ||
35 Utilities | 1124 | ||
35.1?Einführung | 1124 | ||
35.2?Zeit | 1124 | ||
35.2.1?duration | 1125 | ||
35.2.2?time_point | 1128 | ||
35.2.3?Zeitgeber | 1130 | ||
35.2.4?Zeit-Traits | 1131 | ||
35.3 Rationale Arithmetik zur Übersetzungszeit | 1132 | ||
35.4?Typfunktionen | 1134 | ||
35.4.1?Typ-Traits | 1134 | ||
35.4.2?Typgeneratoren | 1139 | ||
35.5?Kleinere Utilities | 1144 | ||
35.5.1?move() and forward() | 1144 | ||
35.5.2?swap() | 1145 | ||
35.5.3?Relationale Operatoren | 1146 | ||
35.5.4?Vergleichen und Hashing von type_info | 1147 | ||
35.6?Ratschläge | 1148 | ||
36 Strings | 1150 | ||
36.1?Einführung | 1150 | ||
36.2?Zeichenklassifizierung | 1150 | ||
36.2.1?Klassifizierungsfunktionen | 1150 | ||
36.2.2?Zeichen-Traits | 1152 | ||
36.3?Strings | 1153 | ||
36.3.1?string im Vergleich zu C-Strings | 1154 | ||
36.3.2?Konstruktoren | 1156 | ||
36.3.3?Fundamentale Operationen | 1158 | ||
36.3.4?String-Ein-/Ausgabe | 1160 | ||
36.3.5?Numerische Konvertierungen | 1160 | ||
36.3.6?STL-ähnliche Operationen | 1162 | ||
36.3.7?Die find-Familie | 1165 | ||
36.3.8?Teilstrings | 1167 | ||
36.4?Ratschläge | 1168 | ||
37 Reguläre Ausdrücke | 1170 | ||
37.1?Reguläre Ausdrücke | 1170 | ||
37.1.1?Notation regulärer Ausdrücke | 1171 | ||
37.2?regex | 1176 | ||
37.2.1?Übereinstimmungsergebnisse | 1178 | ||
37.2.2?Formatierung | 1181 | ||
37.3?Funktionen für reguläre Ausdrücke | 1182 | ||
37.3.1?regex_match() | 1182 | ||
37.3.2?regex_search() | 1184 | ||
37.3.3?regex_replace() | 1185 | ||
37.4?Iteratoren für reguläre Ausdrücke | 1187 | ||
37.4.1?regex_iterator | 1187 | ||
37.4.2?regex_token_iterator | 1188 | ||
37.5?regex_traits | 1191 | ||
37.6?Ratschläge | 1192 | ||
38 E/A-Streams | 1194 | ||
38.1?Einführung | 1194 | ||
38.2?Die E/A-Stream-Hierarchie | 1196 | ||
38.2.1?Datei-Streams | 1197 | ||
38.2.2?String-Streams | 1199 | ||
38.3?Fehlerbehandlung | 1201 | ||
38.4?Ein-/Ausgabeoperationen | 1203 | ||
38.4.1?Eingabeoperationen | 1203 | ||
38.4.1.1?Formatierte Eingabe | 1204 | ||
38.4.1.2?Unformatierte Eingabe | 1205 | ||
38.4.2?Ausgabeoperationen | 1206 | ||
38.4.2.1?Virtuelle Ausgabefunktionen | 1208 | ||
38.4.3?Manipulatoren | 1209 | ||
38.4.4?Stream-Status | 1210 | ||
38.4.5?Formatierung | 1214 | ||
38.4.5.1?Formatierungsstatus | 1215 | ||
38.4.5.2?Standardmanipulatoren | 1217 | ||
38.4.5.3?Benutzerdefinierte Manipulatoren | 1220 | ||
38.5?Stream-Iteratoren | 1222 | ||
38.6?Puffer | 1223 | ||
38.6.1?Ausgabe-Streams und -puffer | 1227 | ||
38.6.2?Eingabe-Streams und -puffer | 1228 | ||
38.6.3?Pufferiteratoren | 1229 | ||
38.6.3.1?istreambuf_iterator | 1230 | ||
38.6.3.2?ostreambuf_iterator | 1231 | ||
38.7?Ratschläge | 1231 | ||
39 Locales | 1234 | ||
39.1?Kulturelle Unterschiede behandeln | 1234 | ||
39.2?Die Klasse locale | 1237 | ||
39.2.1?Benannte Locales | 1239 | ||
39.2.1.1?Neue Locales konstruieren | 1242 | ||
39.2.2?Strings vergleichen | 1243 | ||
39.3?Die Klasse facet | 1244 | ||
39.3.1?Auf Facetten in einem Locale zugreifen | 1245 | ||
39.3.2?Eine einfache benutzerdefinierte Facette | 1246 | ||
39.3.3?Locales und Facetten verwenden | 1249 | ||
39.4?Standardfacetten | 1250 | ||
39.4.1?String-Vergleich | 1252 | ||
39.4.1.1?Benannte collate-Facetten | 1255 | ||
39.4.2?Numerische Formatierung | 1255 | ||
39.4.2.1?Numerische Interpunktion | 1256 | ||
39.4.2.2?Numerische Ausgabe | 1257 | ||
39.4.2.3?Numerische Eingabe | 1260 | ||
39.4.3?Formatierung von Geldbeträgen | 1261 | ||
39.4.3.1?Interpunktion bei Geldbeträgen | 1262 | ||
39.4.3.2?Ausgabe von Geldbeträgen | 1265 | ||
39.4.3.3?Eingabe von Geldbeträgen | 1266 | ||
39.4.4?Datum und Uhrzeit formatieren | 1267 | ||
39.4.4.1?time_put | 1267 | ||
39.4.4.2?time_get | 1268 | ||
39.4.5?Zeichenklassifizierung | 1270 | ||
39.4.6?Zeichencodes konvertieren | 1274 | ||
39.4.7?Meldungen | 1278 | ||
39.4.7.1?Meldungen von anderen Facetten verwenden | 1281 | ||
39.5?Komfortschnittstellen | 1282 | ||
39.5.1?Zeichenklassifizierung | 1282 | ||
39.5.2?Zeichenkonvertierungen | 1283 | ||
39.5.3?String-Konvertierungen | 1283 | ||
39.5.4?Pufferkonvertierungen | 1285 | ||
39.6?Ratschläge | 1285 | ||
40 Numerische Berechnungen | 1288 | ||
40.1?Einführung | 1288 | ||
40.2?Numerische Grenzen | 1288 | ||
40.2.1?Makros für Grenzwerte | 1291 | ||
40.3?Mathematische Standardfunktionen | 1292 | ||
40.4?Komplexe Zahlen | 1294 | ||
40.5?Ein numerisches Array: valarray | 1295 | ||
40.5.1?Konstruktoren und Zuweisungen | 1296 | ||
40.5.2?Indizierung | 1298 | ||
40.5.3?Operationen | 1299 | ||
40.5.4?Slices | 1302 | ||
40.5.5?slice_array | 1304 | ||
40.5.6?Verallgemeinerte Slices | 1305 | ||
40.6 Verallgemeinerte numerische Algorithmen | 1306 | ||
40.6.1?accumulate() | 1307 | ||
40.6.2?inner_product() | 1308 | ||
40.6.3?partial_sum() und adjacent_difference() | 1309 | ||
40.6.4?iota() | 1310 | ||
40.7?Zufallszahlen | 1310 | ||
40.7.1?Zufallszahlenmodule | 1313 | ||
40.7.2?Zufallsgerät | 1315 | ||
40.7.3?Verteilungen | 1316 | ||
40.7.4?Zufallszahlen im Stil von C | 1320 | ||
40.8?Ratschläge | 1321 | ||
41 Nebenläufigkeit | 1322 | ||
41.1?Einführung | 1322 | ||
41.2?Speichermodelle | 1324 | ||
41.2.1?Speicherstellen | 1325 | ||
41.2.2?Umordnung von Befehlen | 1326 | ||
41.2.3?Speicherordnung | 1327 | ||
41.2.4?Data Races | 1328 | ||
41.3?Atomare Datentypen | 1330 | ||
41.3.1?Atomare Typen | 1333 | ||
41.3.2?Flags und Fences | 1338 | ||
41.3.3?Atomare Flags | 1338 | ||
41.3.3.1?Fences | 1339 | ||
41.4?volatile | 1339 | ||
41.5?Ratschläge | 1340 | ||
42 Threads und Tasks | 1342 | ||
42.1?Einführung | 1342 | ||
42.2?Threads | 1342 | ||
42.2.1?Identität | 1344 | ||
42.2.2?Konstruktion | 1345 | ||
42.2.3?Zerstörung | 1346 | ||
42.2.4?join() | 1347 | ||
42.2.5?detach() | 1348 | ||
42.2.6?Namespace this_thread | 1350 | ||
42.2.7?Einen Thread vorzeitig beenden | 1351 | ||
42.2.8?thread_local-Daten | 1351 | ||
42.3?Data Races vermeiden | 1353 | ||
42.3.1?Mutexe | 1354 | ||
42.3.1.1?mutex und recursive_mutex | 1355 | ||
42.3.1.2?mutex-Fehler | 1357 | ||
42.3.1.3?timed_mutex und recursive_timed_mutex | 1358 | ||
42.3.1.4?lock_guard und unique_lock | 1359 | ||
42.3.2?Mehrere Sperren | 1363 | ||
42.3.3?call_once() | 1364 | ||
42.3.4?Bedingungsvariablen | 1365 | ||
42.3.4.1?condition_variable_any | 1370 | ||
42.4?Task-basierte Nebenläufigkeit | 1371 | ||
42.4.1?future und promise | 1372 | ||
42.4.2?promise | 1373 | ||
42.4.3?packaged_task | 1374 | ||
42.4.4?future | 1377 | ||
42.4.5?shared_future | 1380 | ||
42.4.6?async() | 1381 | ||
42.4.7?Ein paralleles find()-Beispiel | 1384 | ||
42.5?Ratschläge | 1388 | ||
43 Die C-Standardbibliothek | 1390 | ||
43.1?Einführung | 1390 | ||
43.2?Dateien | 1390 | ||
43.3?Die printf()-Familie | 1391 | ||
43.4?C-Strings | 1396 | ||
43.5?Speicher | 1397 | ||
43.6?Datum und Uhrzeit | 1399 | ||
43.7?Diverses | 1402 | ||
43.8?Ratschläge | 1404 | ||
44 Kompatibilität | 1406 | ||
44.1?Einführung | 1406 | ||
44.2?C++11-Erweiterungen | 1407 | ||
44.2.1?Sprachfeatures | 1407 | ||
44.2.2?Komponenten der Standardbibliothek | 1408 | ||
44.2.3?Veraltete Features | 1409 | ||
44.2.4?Umgang mit älteren C++-Implementierungen | 1410 | ||
44.3?C/C++-Kompatibilität | 1411 | ||
44.3.1?C und C++ sind Geschwister | 1411 | ||
44.3.2?„Stillschweigende“ Unterschiede | 1413 | ||
44.3.3?C-Code, der kein C++ ist | 1414 | ||
44.3.3.1?Probleme mit „klassischem C“ | 1417 | ||
44.3.3.2?C-Features, die von C++ nicht übernommen wurden | 1417 | ||
44.3.4?C++-Code, der kein C ist | 1417 | ||
44.4?Ratschläge | 1419 | ||
Index | 1422 |